LCOV - code coverage report
Current view: top level - src/backend/catalog - dependency.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 753 837 90.0 %
Date: 2024-11-06 16:15:14 Functions: 27 27 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * dependency.c
       4             :  *    Routines to support inter-object dependencies.
       5             :  *
       6             :  *
       7             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
       8             :  * Portions Copyright (c) 1994, Regents of the University of California
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/catalog/dependency.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             :  */
      15             : #include "postgres.h"
      16             : 
      17             : #include "access/genam.h"
      18             : #include "access/htup_details.h"
      19             : #include "access/table.h"
      20             : #include "access/xact.h"
      21             : #include "catalog/catalog.h"
      22             : #include "catalog/dependency.h"
      23             : #include "catalog/heap.h"
      24             : #include "catalog/index.h"
      25             : #include "catalog/objectaccess.h"
      26             : #include "catalog/pg_am.h"
      27             : #include "catalog/pg_amop.h"
      28             : #include "catalog/pg_amproc.h"
      29             : #include "catalog/pg_attrdef.h"
      30             : #include "catalog/pg_authid.h"
      31             : #include "catalog/pg_auth_members.h"
      32             : #include "catalog/pg_cast.h"
      33             : #include "catalog/pg_collation.h"
      34             : #include "catalog/pg_constraint.h"
      35             : #include "catalog/pg_conversion.h"
      36             : #include "catalog/pg_database.h"
      37             : #include "catalog/pg_default_acl.h"
      38             : #include "catalog/pg_depend.h"
      39             : #include "catalog/pg_event_trigger.h"
      40             : #include "catalog/pg_extension.h"
      41             : #include "catalog/pg_foreign_data_wrapper.h"
      42             : #include "catalog/pg_foreign_server.h"
      43             : #include "catalog/pg_init_privs.h"
      44             : #include "catalog/pg_language.h"
      45             : #include "catalog/pg_largeobject.h"
      46             : #include "catalog/pg_namespace.h"
      47             : #include "catalog/pg_opclass.h"
      48             : #include "catalog/pg_operator.h"
      49             : #include "catalog/pg_opfamily.h"
      50             : #include "catalog/pg_parameter_acl.h"
      51             : #include "catalog/pg_policy.h"
      52             : #include "catalog/pg_proc.h"
      53             : #include "catalog/pg_publication.h"
      54             : #include "catalog/pg_publication_namespace.h"
      55             : #include "catalog/pg_publication_rel.h"
      56             : #include "catalog/pg_rewrite.h"
      57             : #include "catalog/pg_statistic_ext.h"
      58             : #include "catalog/pg_subscription.h"
      59             : #include "catalog/pg_tablespace.h"
      60             : #include "catalog/pg_transform.h"
      61             : #include "catalog/pg_trigger.h"
      62             : #include "catalog/pg_ts_config.h"
      63             : #include "catalog/pg_ts_dict.h"
      64             : #include "catalog/pg_ts_parser.h"
      65             : #include "catalog/pg_ts_template.h"
      66             : #include "catalog/pg_type.h"
      67             : #include "catalog/pg_user_mapping.h"
      68             : #include "commands/comment.h"
      69             : #include "commands/defrem.h"
      70             : #include "commands/event_trigger.h"
      71             : #include "commands/extension.h"
      72             : #include "commands/policy.h"
      73             : #include "commands/publicationcmds.h"
      74             : #include "commands/seclabel.h"
      75             : #include "commands/sequence.h"
      76             : #include "commands/trigger.h"
      77             : #include "commands/typecmds.h"
      78             : #include "funcapi.h"
      79             : #include "miscadmin.h"
      80             : #include "nodes/nodeFuncs.h"
      81             : #include "parser/parsetree.h"
      82             : #include "rewrite/rewriteRemove.h"
      83             : #include "storage/lmgr.h"
      84             : #include "utils/fmgroids.h"
      85             : #include "utils/lsyscache.h"
      86             : #include "utils/syscache.h"
      87             : 
      88             : 
      89             : /*
      90             :  * Deletion processing requires additional state for each ObjectAddress that
      91             :  * it's planning to delete.  For simplicity and code-sharing we make the
      92             :  * ObjectAddresses code support arrays with or without this extra state.
      93             :  */
      94             : typedef struct
      95             : {
      96             :     int         flags;          /* bitmask, see bit definitions below */
      97             :     ObjectAddress dependee;     /* object whose deletion forced this one */
      98             : } ObjectAddressExtra;
      99             : 
     100             : /* ObjectAddressExtra flag bits */
     101             : #define DEPFLAG_ORIGINAL    0x0001  /* an original deletion target */
     102             : #define DEPFLAG_NORMAL      0x0002  /* reached via normal dependency */
     103             : #define DEPFLAG_AUTO        0x0004  /* reached via auto dependency */
     104             : #define DEPFLAG_INTERNAL    0x0008  /* reached via internal dependency */
     105             : #define DEPFLAG_PARTITION   0x0010  /* reached via partition dependency */
     106             : #define DEPFLAG_EXTENSION   0x0020  /* reached via extension dependency */
     107             : #define DEPFLAG_REVERSE     0x0040  /* reverse internal/extension link */
     108             : #define DEPFLAG_IS_PART     0x0080  /* has a partition dependency */
     109             : #define DEPFLAG_SUBOBJECT   0x0100  /* subobject of another deletable object */
     110             : 
     111             : 
     112             : /* expansible list of ObjectAddresses */
     113             : struct ObjectAddresses
     114             : {
     115             :     ObjectAddress *refs;        /* => palloc'd array */
     116             :     ObjectAddressExtra *extras; /* => palloc'd array, or NULL if not used */
     117             :     int         numrefs;        /* current number of references */
     118             :     int         maxrefs;        /* current size of palloc'd array(s) */
     119             : };
     120             : 
     121             : /* typedef ObjectAddresses appears in dependency.h */
     122             : 
     123             : /* threaded list of ObjectAddresses, for recursion detection */
     124             : typedef struct ObjectAddressStack
     125             : {
     126             :     const ObjectAddress *object;    /* object being visited */
     127             :     int         flags;          /* its current flag bits */
     128             :     struct ObjectAddressStack *next;    /* next outer stack level */
     129             : } ObjectAddressStack;
     130             : 
     131             : /* temporary storage in findDependentObjects */
     132             : typedef struct
     133             : {
     134             :     ObjectAddress obj;          /* object to be deleted --- MUST BE FIRST */
     135             :     int         subflags;       /* flags to pass down when recursing to obj */
     136             : } ObjectAddressAndFlags;
     137             : 
     138             : /* for find_expr_references_walker */
     139             : typedef struct
     140             : {
     141             :     ObjectAddresses *addrs;     /* addresses being accumulated */
     142             :     List       *rtables;        /* list of rangetables to resolve Vars */
     143             : } find_expr_references_context;
     144             : 
     145             : 
     146             : static void findDependentObjects(const ObjectAddress *object,
     147             :                                  int objflags,
     148             :                                  int flags,
     149             :                                  ObjectAddressStack *stack,
     150             :                                  ObjectAddresses *targetObjects,
     151             :                                  const ObjectAddresses *pendingObjects,
     152             :                                  Relation *depRel);
     153             : static void reportDependentObjects(const ObjectAddresses *targetObjects,
     154             :                                    DropBehavior behavior,
     155             :                                    int flags,
     156             :                                    const ObjectAddress *origObject);
     157             : static void deleteOneObject(const ObjectAddress *object,
     158             :                             Relation *depRel, int32 flags);
     159             : static void doDeletion(const ObjectAddress *object, int flags);
     160             : static bool find_expr_references_walker(Node *node,
     161             :                                         find_expr_references_context *context);
     162             : static void process_function_rte_ref(RangeTblEntry *rte, AttrNumber attnum,
     163             :                                      find_expr_references_context *context);
     164             : static void eliminate_duplicate_dependencies(ObjectAddresses *addrs);
     165             : static int  object_address_comparator(const void *a, const void *b);
     166             : static void add_object_address(Oid classId, Oid objectId, int32 subId,
     167             :                                ObjectAddresses *addrs);
     168             : static void add_exact_object_address_extra(const ObjectAddress *object,
     169             :                                            const ObjectAddressExtra *extra,
     170             :                                            ObjectAddresses *addrs);
     171             : static bool object_address_present_add_flags(const ObjectAddress *object,
     172             :                                              int flags,
     173             :                                              ObjectAddresses *addrs);
     174             : static bool stack_address_present_add_flags(const ObjectAddress *object,
     175             :                                             int flags,
     176             :                                             ObjectAddressStack *stack);
     177             : static void DeleteInitPrivs(const ObjectAddress *object);
     178             : 
     179             : 
     180             : /*
     181             :  * Go through the objects given running the final actions on them, and execute
     182             :  * the actual deletion.
     183             :  */
     184             : static void
     185       29482 : deleteObjectsInList(ObjectAddresses *targetObjects, Relation *depRel,
     186             :                     int flags)
     187             : {
     188             :     int         i;
     189             : 
     190             :     /*
     191             :      * Keep track of objects for event triggers, if necessary.
     192             :      */
     193       29482 :     if (trackDroppedObjectsNeeded() && !(flags & PERFORM_DELETION_INTERNAL))
     194             :     {
     195        4030 :         for (i = 0; i < targetObjects->numrefs; i++)
     196             :         {
     197        3368 :             const ObjectAddress *thisobj = &targetObjects->refs[i];
     198        3368 :             const ObjectAddressExtra *extra = &targetObjects->extras[i];
     199        3368 :             bool        original = false;
     200        3368 :             bool        normal = false;
     201             : 
     202        3368 :             if (extra->flags & DEPFLAG_ORIGINAL)
     203         746 :                 original = true;
     204        3368 :             if (extra->flags & DEPFLAG_NORMAL)
     205         330 :                 normal = true;
     206        3368 :             if (extra->flags & DEPFLAG_REVERSE)
     207           0 :                 normal = true;
     208             : 
     209        3368 :             if (EventTriggerSupportsObject(thisobj))
     210             :             {
     211        3256 :                 EventTriggerSQLDropAddObject(thisobj, original, normal);
     212             :             }
     213             :         }
     214             :     }
     215             : 
     216             :     /*
     217             :      * Delete all the objects in the proper order, except that if told to, we
     218             :      * should skip the original object(s).
     219             :      */
     220      205450 :     for (i = 0; i < targetObjects->numrefs; i++)
     221             :     {
     222      175972 :         ObjectAddress *thisobj = targetObjects->refs + i;
     223      175972 :         ObjectAddressExtra *thisextra = targetObjects->extras + i;
     224             : 
     225      175972 :         if ((flags & PERFORM_DELETION_SKIP_ORIGINAL) &&
     226        8664 :             (thisextra->flags & DEPFLAG_ORIGINAL))
     227         794 :             continue;
     228             : 
     229      175178 :         deleteOneObject(thisobj, depRel, flags);
     230             :     }
     231       29478 : }
     232             : 
     233             : /*
     234             :  * performDeletion: attempt to drop the specified object.  If CASCADE
     235             :  * behavior is specified, also drop any dependent objects (recursively).
     236             :  * If RESTRICT behavior is specified, error out if there are any dependent
     237             :  * objects, except for those that should be implicitly dropped anyway
     238             :  * according to the dependency type.
     239             :  *
     240             :  * This is the outer control routine for all forms of DROP that drop objects
     241             :  * that can participate in dependencies.  Note that performMultipleDeletions
     242             :  * is a variant on the same theme; if you change anything here you'll likely
     243             :  * need to fix that too.
     244             :  *
     245             :  * Bits in the flags argument can include:
     246             :  *
     247             :  * PERFORM_DELETION_INTERNAL: indicates that the drop operation is not the
     248             :  * direct result of a user-initiated action.  For example, when a temporary
     249             :  * schema is cleaned out so that a new backend can use it, or when a column
     250             :  * default is dropped as an intermediate step while adding a new one, that's
     251             :  * an internal operation.  On the other hand, when we drop something because
     252             :  * the user issued a DROP statement against it, that's not internal. Currently
     253             :  * this suppresses calling event triggers and making some permissions checks.
     254             :  *
     255             :  * PERFORM_DELETION_CONCURRENTLY: perform the drop concurrently.  This does
     256             :  * not currently work for anything except dropping indexes; don't set it for
     257             :  * other object types or you may get strange results.
     258             :  *
     259             :  * PERFORM_DELETION_QUIETLY: reduce message level from NOTICE to DEBUG2.
     260             :  *
     261             :  * PERFORM_DELETION_SKIP_ORIGINAL: do not delete the specified object(s),
     262             :  * but only what depends on it/them.
     263             :  *
     264             :  * PERFORM_DELETION_SKIP_EXTENSIONS: do not delete extensions, even when
     265             :  * deleting objects that are part of an extension.  This should generally
     266             :  * be used only when dropping temporary objects.
     267             :  *
     268             :  * PERFORM_DELETION_CONCURRENT_LOCK: perform the drop normally but with a lock
     269             :  * as if it were concurrent.  This is used by REINDEX CONCURRENTLY.
     270             :  *
     271             :  */
     272             : void
     273        4934 : performDeletion(const ObjectAddress *object,
     274             :                 DropBehavior behavior, int flags)
     275             : {
     276             :     Relation    depRel;
     277             :     ObjectAddresses *targetObjects;
     278             : 
     279             :     /*
     280             :      * We save some cycles by opening pg_depend just once and passing the
     281             :      * Relation pointer down to all the recursive deletion steps.
     282             :      */
     283        4934 :     depRel = table_open(DependRelationId, RowExclusiveLock);
     284             : 
     285             :     /*
     286             :      * Acquire deletion lock on the target object.  (Ideally the caller has
     287             :      * done this already, but many places are sloppy about it.)
     288             :      */
     289        4934 :     AcquireDeletionLock(object, 0);
     290             : 
     291             :     /*
     292             :      * Construct a list of objects to delete (ie, the given object plus
     293             :      * everything directly or indirectly dependent on it).
     294             :      */
     295        4934 :     targetObjects = new_object_addresses();
     296             : 
     297        4934 :     findDependentObjects(object,
     298             :                          DEPFLAG_ORIGINAL,
     299             :                          flags,
     300             :                          NULL,  /* empty stack */
     301             :                          targetObjects,
     302             :                          NULL,  /* no pendingObjects */
     303             :                          &depRel);
     304             : 
     305             :     /*
     306             :      * Check if deletion is allowed, and report about cascaded deletes.
     307             :      */
     308        4934 :     reportDependentObjects(targetObjects,
     309             :                            behavior,
     310             :                            flags,
     311             :                            object);
     312             : 
     313             :     /* do the deed */
     314        4898 :     deleteObjectsInList(targetObjects, &depRel, flags);
     315             : 
     316             :     /* And clean up */
     317        4896 :     free_object_addresses(targetObjects);
     318             : 
     319        4896 :     table_close(depRel, RowExclusiveLock);
     320        4896 : }
     321             : 
     322             : /*
     323             :  * performMultipleDeletions: Similar to performDeletion, but act on multiple
     324             :  * objects at once.
     325             :  *
     326             :  * The main difference from issuing multiple performDeletion calls is that the
     327             :  * list of objects that would be implicitly dropped, for each object to be
     328             :  * dropped, is the union of the implicit-object list for all objects.  This
     329             :  * makes each check be more relaxed.
     330             :  */
     331             : void
     332       27038 : performMultipleDeletions(const ObjectAddresses *objects,
     333             :                          DropBehavior behavior, int flags)
     334             : {
     335             :     Relation    depRel;
     336             :     ObjectAddresses *targetObjects;
     337             :     int         i;
     338             : 
     339             :     /* No work if no objects... */
     340       27038 :     if (objects->numrefs <= 0)
     341        2116 :         return;
     342             : 
     343             :     /*
     344             :      * We save some cycles by opening pg_depend just once and passing the
     345             :      * Relation pointer down to all the recursive deletion steps.
     346             :      */
     347       24922 :     depRel = table_open(DependRelationId, RowExclusiveLock);
     348             : 
     349             :     /*
     350             :      * Construct a list of objects to delete (ie, the given objects plus
     351             :      * everything directly or indirectly dependent on them).  Note that
     352             :      * because we pass the whole objects list as pendingObjects context, we
     353             :      * won't get a failure from trying to delete an object that is internally
     354             :      * dependent on another one in the list; we'll just skip that object and
     355             :      * delete it when we reach its owner.
     356             :      */
     357       24922 :     targetObjects = new_object_addresses();
     358             : 
     359       54732 :     for (i = 0; i < objects->numrefs; i++)
     360             :     {
     361       29852 :         const ObjectAddress *thisobj = objects->refs + i;
     362             : 
     363             :         /*
     364             :          * Acquire deletion lock on each target object.  (Ideally the caller
     365             :          * has done this already, but many places are sloppy about it.)
     366             :          */
     367       29852 :         AcquireDeletionLock(thisobj, flags);
     368             : 
     369       29852 :         findDependentObjects(thisobj,
     370             :                              DEPFLAG_ORIGINAL,
     371             :                              flags,
     372             :                              NULL,  /* empty stack */
     373             :                              targetObjects,
     374             :                              objects,
     375             :                              &depRel);
     376             :     }
     377             : 
     378             :     /*
     379             :      * Check if deletion is allowed, and report about cascaded deletes.
     380             :      *
     381             :      * If there's exactly one object being deleted, report it the same way as
     382             :      * in performDeletion(), else we have to be vaguer.
     383             :      */
     384       24880 :     reportDependentObjects(targetObjects,
     385             :                            behavior,
     386             :                            flags,
     387       24880 :                            (objects->numrefs == 1 ? objects->refs : NULL));
     388             : 
     389             :     /* do the deed */
     390       24584 :     deleteObjectsInList(targetObjects, &depRel, flags);
     391             : 
     392             :     /* And clean up */
     393       24582 :     free_object_addresses(targetObjects);
     394             : 
     395       24582 :     table_close(depRel, RowExclusiveLock);
     396             : }
     397             : 
     398             : /*
     399             :  * findDependentObjects - find all objects that depend on 'object'
     400             :  *
     401             :  * For every object that depends on the starting object, acquire a deletion
     402             :  * lock on the object, add it to targetObjects (if not already there),
     403             :  * and recursively find objects that depend on it.  An object's dependencies
     404             :  * will be placed into targetObjects before the object itself; this means
     405             :  * that the finished list's order represents a safe deletion order.
     406             :  *
     407             :  * The caller must already have a deletion lock on 'object' itself,
     408             :  * but must not have added it to targetObjects.  (Note: there are corner
     409             :  * cases where we won't add the object either, and will also release the
     410             :  * caller-taken lock.  This is a bit ugly, but the API is set up this way
     411             :  * to allow easy rechecking of an object's liveness after we lock it.  See
     412             :  * notes within the function.)
     413             :  *
     414             :  * When dropping a whole object (subId = 0), we find dependencies for
     415             :  * its sub-objects too.
     416             :  *
     417             :  *  object: the object to add to targetObjects and find dependencies on
     418             :  *  objflags: flags to be ORed into the object's targetObjects entry
     419             :  *  flags: PERFORM_DELETION_xxx flags for the deletion operation as a whole
     420             :  *  stack: list of objects being visited in current recursion; topmost item
     421             :  *          is the object that we recursed from (NULL for external callers)
     422             :  *  targetObjects: list of objects that are scheduled to be deleted
     423             :  *  pendingObjects: list of other objects slated for destruction, but
     424             :  *          not necessarily in targetObjects yet (can be NULL if none)
     425             :  *  *depRel: already opened pg_depend relation
     426             :  *
     427             :  * Note: objflags describes the reason for visiting this particular object
     428             :  * at this time, and is not passed down when recursing.  The flags argument
     429             :  * is passed down, since it describes what we're doing overall.
     430             :  */
     431             : static void
     432      223150 : findDependentObjects(const ObjectAddress *object,
     433             :                      int objflags,
     434             :                      int flags,
     435             :                      ObjectAddressStack *stack,
     436             :                      ObjectAddresses *targetObjects,
     437             :                      const ObjectAddresses *pendingObjects,
     438             :                      Relation *depRel)
     439             : {
     440             :     ScanKeyData key[3];
     441             :     int         nkeys;
     442             :     SysScanDesc scan;
     443             :     HeapTuple   tup;
     444             :     ObjectAddress otherObject;
     445             :     ObjectAddress owningObject;
     446             :     ObjectAddress partitionObject;
     447             :     ObjectAddressAndFlags *dependentObjects;
     448             :     int         numDependentObjects;
     449             :     int         maxDependentObjects;
     450             :     ObjectAddressStack mystack;
     451             :     ObjectAddressExtra extra;
     452             : 
     453             :     /*
     454             :      * If the target object is already being visited in an outer recursion
     455             :      * level, just report the current objflags back to that level and exit.
     456             :      * This is needed to avoid infinite recursion in the face of circular
     457             :      * dependencies.
     458             :      *
     459             :      * The stack check alone would result in dependency loops being broken at
     460             :      * an arbitrary point, ie, the first member object of the loop to be
     461             :      * visited is the last one to be deleted.  This is obviously unworkable.
     462             :      * However, the check for internal dependency below guarantees that we
     463             :      * will not break a loop at an internal dependency: if we enter the loop
     464             :      * at an "owned" object we will switch and start at the "owning" object
     465             :      * instead.  We could probably hack something up to avoid breaking at an
     466             :      * auto dependency, too, if we had to.  However there are no known cases
     467             :      * where that would be necessary.
     468             :      */
     469      223150 :     if (stack_address_present_add_flags(object, objflags, stack))
     470       43100 :         return;
     471             : 
     472             :     /*
     473             :      * since this function recurses, it could be driven to stack overflow,
     474             :      * because of the deep dependency tree, not only due to dependency loops.
     475             :      */
     476      222880 :     check_stack_depth();
     477             : 
     478             :     /*
     479             :      * It's also possible that the target object has already been completely
     480             :      * processed and put into targetObjects.  If so, again we just add the
     481             :      * specified objflags to its entry and return.
     482             :      *
     483             :      * (Note: in these early-exit cases we could release the caller-taken
     484             :      * lock, since the object is presumably now locked multiple times; but it
     485             :      * seems not worth the cycles.)
     486             :      */
     487      222880 :     if (object_address_present_add_flags(object, objflags, targetObjects))
     488       41310 :         return;
     489             : 
     490             :     /*
     491             :      * If the target object is pinned, we can just error out immediately; it
     492             :      * won't have any objects recorded as depending on it.
     493             :      */
     494      181570 :     if (IsPinnedObject(object->classId, object->objectId))
     495           2 :         ereport(ERROR,
     496             :                 (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
     497             :                  errmsg("cannot drop %s because it is required by the database system",
     498             :                         getObjectDescription(object, false))));
     499             : 
     500             :     /*
     501             :      * The target object might be internally dependent on some other object
     502             :      * (its "owner"), and/or be a member of an extension (also considered its
     503             :      * owner).  If so, and if we aren't recursing from the owning object, we
     504             :      * have to transform this deletion request into a deletion request of the
     505             :      * owning object.  (We'll eventually recurse back to this object, but the
     506             :      * owning object has to be visited first so it will be deleted after.) The
     507             :      * way to find out about this is to scan the pg_depend entries that show
     508             :      * what this object depends on.
     509             :      */
     510      181568 :     ScanKeyInit(&key[0],
     511             :                 Anum_pg_depend_classid,
     512             :                 BTEqualStrategyNumber, F_OIDEQ,
     513             :                 ObjectIdGetDatum(object->classId));
     514      181568 :     ScanKeyInit(&key[1],
     515             :                 Anum_pg_depend_objid,
     516             :                 BTEqualStrategyNumber, F_OIDEQ,
     517             :                 ObjectIdGetDatum(object->objectId));
     518      181568 :     if (object->objectSubId != 0)
     519             :     {
     520             :         /* Consider only dependencies of this sub-object */
     521        2098 :         ScanKeyInit(&key[2],
     522             :                     Anum_pg_depend_objsubid,
     523             :                     BTEqualStrategyNumber, F_INT4EQ,
     524             :                     Int32GetDatum(object->objectSubId));
     525        2098 :         nkeys = 3;
     526             :     }
     527             :     else
     528             :     {
     529             :         /* Consider dependencies of this object and any sub-objects it has */
     530      179470 :         nkeys = 2;
     531             :     }
     532             : 
     533      181568 :     scan = systable_beginscan(*depRel, DependDependerIndexId, true,
     534             :                               NULL, nkeys, key);
     535             : 
     536             :     /* initialize variables that loop may fill */
     537      181568 :     memset(&owningObject, 0, sizeof(owningObject));
     538      181568 :     memset(&partitionObject, 0, sizeof(partitionObject));
     539             : 
     540      438536 :     while (HeapTupleIsValid(tup = systable_getnext(scan)))
     541             :     {
     542      258488 :         Form_pg_depend foundDep = (Form_pg_depend) GETSTRUCT(tup);
     543             : 
     544      258488 :         otherObject.classId = foundDep->refclassid;
     545      258488 :         otherObject.objectId = foundDep->refobjid;
     546      258488 :         otherObject.objectSubId = foundDep->refobjsubid;
     547             : 
     548             :         /*
     549             :          * When scanning dependencies of a whole object, we may find rows
     550             :          * linking sub-objects of the object to the object itself.  (Normally,
     551             :          * such a dependency is implicit, but we must make explicit ones in
     552             :          * some cases involving partitioning.)  We must ignore such rows to
     553             :          * avoid infinite recursion.
     554             :          */
     555      258488 :         if (otherObject.classId == object->classId &&
     556       91234 :             otherObject.objectId == object->objectId &&
     557        4114 :             object->objectSubId == 0)
     558        4090 :             continue;
     559             : 
     560      254398 :         switch (foundDep->deptype)
     561             :         {
     562      142380 :             case DEPENDENCY_NORMAL:
     563             :             case DEPENDENCY_AUTO:
     564             :             case DEPENDENCY_AUTO_EXTENSION:
     565             :                 /* no problem */
     566      142380 :                 break;
     567             : 
     568        3236 :             case DEPENDENCY_EXTENSION:
     569             : 
     570             :                 /*
     571             :                  * If told to, ignore EXTENSION dependencies altogether.  This
     572             :                  * flag is normally used to prevent dropping extensions during
     573             :                  * temporary-object cleanup, even if a temp object was created
     574             :                  * during an extension script.
     575             :                  */
     576        3236 :                 if (flags & PERFORM_DELETION_SKIP_EXTENSIONS)
     577           8 :                     break;
     578             : 
     579             :                 /*
     580             :                  * If the other object is the extension currently being
     581             :                  * created/altered, ignore this dependency and continue with
     582             :                  * the deletion.  This allows dropping of an extension's
     583             :                  * objects within the extension's scripts, as well as corner
     584             :                  * cases such as dropping a transient object created within
     585             :                  * such a script.
     586             :                  */
     587        3228 :                 if (creating_extension &&
     588         322 :                     otherObject.classId == ExtensionRelationId &&
     589         322 :                     otherObject.objectId == CurrentExtensionObject)
     590         322 :                     break;
     591             : 
     592             :                 /* Otherwise, treat this like an internal dependency */
     593             :                 /* FALL THRU */
     594             : 
     595             :             case DEPENDENCY_INTERNAL:
     596             : 
     597             :                 /*
     598             :                  * This object is part of the internal implementation of
     599             :                  * another object, or is part of the extension that is the
     600             :                  * other object.  We have three cases:
     601             :                  *
     602             :                  * 1. At the outermost recursion level, we must disallow the
     603             :                  * DROP.  However, if the owning object is listed in
     604             :                  * pendingObjects, just release the caller's lock and return;
     605             :                  * we'll eventually complete the DROP when we reach that entry
     606             :                  * in the pending list.
     607             :                  *
     608             :                  * Note: the above statement is true only if this pg_depend
     609             :                  * entry still exists by then; in principle, therefore, we
     610             :                  * could miss deleting an item the user told us to delete.
     611             :                  * However, no inconsistency can result: since we're at outer
     612             :                  * level, there is no object depending on this one.
     613             :                  */
     614      102276 :                 if (stack == NULL)
     615             :                 {
     616          80 :                     if (pendingObjects &&
     617          40 :                         object_address_present(&otherObject, pendingObjects))
     618             :                     {
     619           0 :                         systable_endscan(scan);
     620             :                         /* need to release caller's lock; see notes below */
     621           0 :                         ReleaseDeletionLock(object);
     622           0 :                         return;
     623             :                     }
     624             : 
     625             :                     /*
     626             :                      * We postpone actually issuing the error message until
     627             :                      * after this loop, so that we can make the behavior
     628             :                      * independent of the ordering of pg_depend entries, at
     629             :                      * least if there's not more than one INTERNAL and one
     630             :                      * EXTENSION dependency.  (If there's more, we'll complain
     631             :                      * about a random one of them.)  Prefer to complain about
     632             :                      * EXTENSION, since that's generally a more important
     633             :                      * dependency.
     634             :                      */
     635          40 :                     if (!OidIsValid(owningObject.classId) ||
     636           0 :                         foundDep->deptype == DEPENDENCY_EXTENSION)
     637          40 :                         owningObject = otherObject;
     638          40 :                     break;
     639             :                 }
     640             : 
     641             :                 /*
     642             :                  * 2. When recursing from the other end of this dependency,
     643             :                  * it's okay to continue with the deletion.  This holds when
     644             :                  * recursing from a whole object that includes the nominal
     645             :                  * other end as a component, too.  Since there can be more
     646             :                  * than one "owning" object, we have to allow matches that are
     647             :                  * more than one level down in the stack.
     648             :                  */
     649      102236 :                 if (stack_address_present_add_flags(&otherObject, 0, stack))
     650      100716 :                     break;
     651             : 
     652             :                 /*
     653             :                  * 3. Not all the owning objects have been visited, so
     654             :                  * transform this deletion request into a delete of this
     655             :                  * owning object.
     656             :                  *
     657             :                  * First, release caller's lock on this object and get
     658             :                  * deletion lock on the owning object.  (We must release
     659             :                  * caller's lock to avoid deadlock against a concurrent
     660             :                  * deletion of the owning object.)
     661             :                  */
     662        1520 :                 ReleaseDeletionLock(object);
     663        1520 :                 AcquireDeletionLock(&otherObject, 0);
     664             : 
     665             :                 /*
     666             :                  * The owning object might have been deleted while we waited
     667             :                  * to lock it; if so, neither it nor the current object are
     668             :                  * interesting anymore.  We test this by checking the
     669             :                  * pg_depend entry (see notes below).
     670             :                  */
     671        1520 :                 if (!systable_recheck_tuple(scan, tup))
     672             :                 {
     673           0 :                     systable_endscan(scan);
     674           0 :                     ReleaseDeletionLock(&otherObject);
     675           0 :                     return;
     676             :                 }
     677             : 
     678             :                 /*
     679             :                  * One way or the other, we're done with the scan; might as
     680             :                  * well close it down before recursing, to reduce peak
     681             :                  * resource consumption.
     682             :                  */
     683        1520 :                 systable_endscan(scan);
     684             : 
     685             :                 /*
     686             :                  * Okay, recurse to the owning object instead of proceeding.
     687             :                  *
     688             :                  * We do not need to stack the current object; we want the
     689             :                  * traversal order to be as if the original reference had
     690             :                  * linked to the owning object instead of this one.
     691             :                  *
     692             :                  * The dependency type is a "reverse" dependency: we need to
     693             :                  * delete the owning object if this one is to be deleted, but
     694             :                  * this linkage is never a reason for an automatic deletion.
     695             :                  */
     696        1520 :                 findDependentObjects(&otherObject,
     697             :                                      DEPFLAG_REVERSE,
     698             :                                      flags,
     699             :                                      stack,
     700             :                                      targetObjects,
     701             :                                      pendingObjects,
     702             :                                      depRel);
     703             : 
     704             :                 /*
     705             :                  * The current target object should have been added to
     706             :                  * targetObjects while processing the owning object; but it
     707             :                  * probably got only the flag bits associated with the
     708             :                  * dependency we're looking at.  We need to add the objflags
     709             :                  * that were passed to this recursion level, too, else we may
     710             :                  * get a bogus failure in reportDependentObjects (if, for
     711             :                  * example, we were called due to a partition dependency).
     712             :                  *
     713             :                  * If somehow the current object didn't get scheduled for
     714             :                  * deletion, bleat.  (That would imply that somebody deleted
     715             :                  * this dependency record before the recursion got to it.)
     716             :                  * Another idea would be to reacquire lock on the current
     717             :                  * object and resume trying to delete it, but it seems not
     718             :                  * worth dealing with the race conditions inherent in that.
     719             :                  */
     720        1520 :                 if (!object_address_present_add_flags(object, objflags,
     721             :                                                       targetObjects))
     722           0 :                     elog(ERROR, "deletion of owning object %s failed to delete %s",
     723             :                          getObjectDescription(&otherObject, false),
     724             :                          getObjectDescription(object, false));
     725             : 
     726             :                 /* And we're done here. */
     727        1520 :                 return;
     728             : 
     729        4706 :             case DEPENDENCY_PARTITION_PRI:
     730             : 
     731             :                 /*
     732             :                  * Remember that this object has a partition-type dependency.
     733             :                  * After the dependency scan, we'll complain if we didn't find
     734             :                  * a reason to delete one of its partition dependencies.
     735             :                  */
     736        4706 :                 objflags |= DEPFLAG_IS_PART;
     737             : 
     738             :                 /*
     739             :                  * Also remember the primary partition owner, for error
     740             :                  * messages.  If there are multiple primary owners (which
     741             :                  * there should not be), we'll report a random one of them.
     742             :                  */
     743        4706 :                 partitionObject = otherObject;
     744        4706 :                 break;
     745             : 
     746        4706 :             case DEPENDENCY_PARTITION_SEC:
     747             : 
     748             :                 /*
     749             :                  * Only use secondary partition owners in error messages if we
     750             :                  * find no primary owner (which probably shouldn't happen).
     751             :                  */
     752        4706 :                 if (!(objflags & DEPFLAG_IS_PART))
     753           0 :                     partitionObject = otherObject;
     754             : 
     755             :                 /*
     756             :                  * Remember that this object has a partition-type dependency.
     757             :                  * After the dependency scan, we'll complain if we didn't find
     758             :                  * a reason to delete one of its partition dependencies.
     759             :                  */
     760        4706 :                 objflags |= DEPFLAG_IS_PART;
     761        4706 :                 break;
     762             : 
     763           0 :             default:
     764           0 :                 elog(ERROR, "unrecognized dependency type '%c' for %s",
     765             :                      foundDep->deptype, getObjectDescription(object, false));
     766             :                 break;
     767             :         }
     768             :     }
     769             : 
     770      180048 :     systable_endscan(scan);
     771             : 
     772             :     /*
     773             :      * If we found an INTERNAL or EXTENSION dependency when we're at outer
     774             :      * level, complain about it now.  If we also found a PARTITION dependency,
     775             :      * we prefer to report the PARTITION dependency.  This is arbitrary but
     776             :      * seems to be more useful in practice.
     777             :      */
     778      180048 :     if (OidIsValid(owningObject.classId))
     779             :     {
     780             :         char       *otherObjDesc;
     781             : 
     782          40 :         if (OidIsValid(partitionObject.classId))
     783          12 :             otherObjDesc = getObjectDescription(&partitionObject, false);
     784             :         else
     785          28 :             otherObjDesc = getObjectDescription(&owningObject, false);
     786             : 
     787          40 :         ereport(ERROR,
     788             :                 (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
     789             :                  errmsg("cannot drop %s because %s requires it",
     790             :                         getObjectDescription(object, false), otherObjDesc),
     791             :                  errhint("You can drop %s instead.", otherObjDesc)));
     792             :     }
     793             : 
     794             :     /*
     795             :      * Next, identify all objects that directly depend on the current object.
     796             :      * To ensure predictable deletion order, we collect them up in
     797             :      * dependentObjects and sort the list before actually recursing.  (The
     798             :      * deletion order would be valid in any case, but doing this ensures
     799             :      * consistent output from DROP CASCADE commands, which is helpful for
     800             :      * regression testing.)
     801             :      */
     802      180008 :     maxDependentObjects = 128;  /* arbitrary initial allocation */
     803             :     dependentObjects = (ObjectAddressAndFlags *)
     804      180008 :         palloc(maxDependentObjects * sizeof(ObjectAddressAndFlags));
     805      180008 :     numDependentObjects = 0;
     806             : 
     807      180008 :     ScanKeyInit(&key[0],
     808             :                 Anum_pg_depend_refclassid,
     809             :                 BTEqualStrategyNumber, F_OIDEQ,
     810             :                 ObjectIdGetDatum(object->classId));
     811      180008 :     ScanKeyInit(&key[1],
     812             :                 Anum_pg_depend_refobjid,
     813             :                 BTEqualStrategyNumber, F_OIDEQ,
     814             :                 ObjectIdGetDatum(object->objectId));
     815      180008 :     if (object->objectSubId != 0)
     816             :     {
     817        2074 :         ScanKeyInit(&key[2],
     818             :                     Anum_pg_depend_refobjsubid,
     819             :                     BTEqualStrategyNumber, F_INT4EQ,
     820             :                     Int32GetDatum(object->objectSubId));
     821        2074 :         nkeys = 3;
     822             :     }
     823             :     else
     824      177934 :         nkeys = 2;
     825             : 
     826      180008 :     scan = systable_beginscan(*depRel, DependReferenceIndexId, true,
     827             :                               NULL, nkeys, key);
     828             : 
     829      370942 :     while (HeapTupleIsValid(tup = systable_getnext(scan)))
     830             :     {
     831      190934 :         Form_pg_depend foundDep = (Form_pg_depend) GETSTRUCT(tup);
     832             :         int         subflags;
     833             : 
     834      190934 :         otherObject.classId = foundDep->classid;
     835      190934 :         otherObject.objectId = foundDep->objid;
     836      190934 :         otherObject.objectSubId = foundDep->objsubid;
     837             : 
     838             :         /*
     839             :          * If what we found is a sub-object of the current object, just ignore
     840             :          * it.  (Normally, such a dependency is implicit, but we must make
     841             :          * explicit ones in some cases involving partitioning.)
     842             :          */
     843      190934 :         if (otherObject.classId == object->classId &&
     844       87156 :             otherObject.objectId == object->objectId &&
     845        4090 :             object->objectSubId == 0)
     846        4090 :             continue;
     847             : 
     848             :         /*
     849             :          * Must lock the dependent object before recursing to it.
     850             :          */
     851      186844 :         AcquireDeletionLock(&otherObject, 0);
     852             : 
     853             :         /*
     854             :          * The dependent object might have been deleted while we waited to
     855             :          * lock it; if so, we don't need to do anything more with it. We can
     856             :          * test this cheaply and independently of the object's type by seeing
     857             :          * if the pg_depend tuple we are looking at is still live. (If the
     858             :          * object got deleted, the tuple would have been deleted too.)
     859             :          */
     860      186844 :         if (!systable_recheck_tuple(scan, tup))
     861             :         {
     862             :             /* release the now-useless lock */
     863           0 :             ReleaseDeletionLock(&otherObject);
     864             :             /* and continue scanning for dependencies */
     865           0 :             continue;
     866             :         }
     867             : 
     868             :         /*
     869             :          * We do need to delete it, so identify objflags to be passed down,
     870             :          * which depend on the dependency type.
     871             :          */
     872      186844 :         switch (foundDep->deptype)
     873             :         {
     874       25388 :             case DEPENDENCY_NORMAL:
     875       25388 :                 subflags = DEPFLAG_NORMAL;
     876       25388 :                 break;
     877       52252 :             case DEPENDENCY_AUTO:
     878             :             case DEPENDENCY_AUTO_EXTENSION:
     879       52252 :                 subflags = DEPFLAG_AUTO;
     880       52252 :                 break;
     881       97820 :             case DEPENDENCY_INTERNAL:
     882       97820 :                 subflags = DEPFLAG_INTERNAL;
     883       97820 :                 break;
     884        8540 :             case DEPENDENCY_PARTITION_PRI:
     885             :             case DEPENDENCY_PARTITION_SEC:
     886        8540 :                 subflags = DEPFLAG_PARTITION;
     887        8540 :                 break;
     888        2844 :             case DEPENDENCY_EXTENSION:
     889        2844 :                 subflags = DEPFLAG_EXTENSION;
     890        2844 :                 break;
     891           0 :             default:
     892           0 :                 elog(ERROR, "unrecognized dependency type '%c' for %s",
     893             :                      foundDep->deptype, getObjectDescription(object, false));
     894             :                 subflags = 0;   /* keep compiler quiet */
     895             :                 break;
     896             :         }
     897             : 
     898             :         /* And add it to the pending-objects list */
     899      186844 :         if (numDependentObjects >= maxDependentObjects)
     900             :         {
     901             :             /* enlarge array if needed */
     902           8 :             maxDependentObjects *= 2;
     903             :             dependentObjects = (ObjectAddressAndFlags *)
     904           8 :                 repalloc(dependentObjects,
     905             :                          maxDependentObjects * sizeof(ObjectAddressAndFlags));
     906             :         }
     907             : 
     908      186844 :         dependentObjects[numDependentObjects].obj = otherObject;
     909      186844 :         dependentObjects[numDependentObjects].subflags = subflags;
     910      186844 :         numDependentObjects++;
     911             :     }
     912             : 
     913      180008 :     systable_endscan(scan);
     914             : 
     915             :     /*
     916             :      * Now we can sort the dependent objects into a stable visitation order.
     917             :      * It's safe to use object_address_comparator here since the obj field is
     918             :      * first within ObjectAddressAndFlags.
     919             :      */
     920      180008 :     if (numDependentObjects > 1)
     921       40982 :         qsort(dependentObjects, numDependentObjects,
     922             :               sizeof(ObjectAddressAndFlags),
     923             :               object_address_comparator);
     924             : 
     925             :     /*
     926             :      * Now recurse to the dependent objects.  We must visit them first since
     927             :      * they have to be deleted before the current object.
     928             :      */
     929      180008 :     mystack.object = object;    /* set up a new stack level */
     930      180008 :     mystack.flags = objflags;
     931      180008 :     mystack.next = stack;
     932             : 
     933      366852 :     for (int i = 0; i < numDependentObjects; i++)
     934             :     {
     935      186844 :         ObjectAddressAndFlags *depObj = dependentObjects + i;
     936             : 
     937      186844 :         findDependentObjects(&depObj->obj,
     938             :                              depObj->subflags,
     939             :                              flags,
     940             :                              &mystack,
     941             :                              targetObjects,
     942             :                              pendingObjects,
     943             :                              depRel);
     944             :     }
     945             : 
     946      180008 :     pfree(dependentObjects);
     947             : 
     948             :     /*
     949             :      * Finally, we can add the target object to targetObjects.  Be careful to
     950             :      * include any flags that were passed back down to us from inner recursion
     951             :      * levels.  Record the "dependee" as being either the most important
     952             :      * partition owner if there is one, else the object we recursed from, if
     953             :      * any.  (The logic in reportDependentObjects() is such that it can only
     954             :      * need one of those objects.)
     955             :      */
     956      180008 :     extra.flags = mystack.flags;
     957      180008 :     if (extra.flags & DEPFLAG_IS_PART)
     958        4694 :         extra.dependee = partitionObject;
     959      175314 :     else if (stack)
     960      141078 :         extra.dependee = *stack->object;
     961             :     else
     962       34236 :         memset(&extra.dependee, 0, sizeof(extra.dependee));
     963      180008 :     add_exact_object_address_extra(object, &extra, targetObjects);
     964             : }
     965             : 
     966             : /*
     967             :  * reportDependentObjects - report about dependencies, and fail if RESTRICT
     968             :  *
     969             :  * Tell the user about dependent objects that we are going to delete
     970             :  * (or would need to delete, but are prevented by RESTRICT mode);
     971             :  * then error out if there are any and it's not CASCADE mode.
     972             :  *
     973             :  *  targetObjects: list of objects that are scheduled to be deleted
     974             :  *  behavior: RESTRICT or CASCADE
     975             :  *  flags: other flags for the deletion operation
     976             :  *  origObject: base object of deletion, or NULL if not available
     977             :  *      (the latter case occurs in DROP OWNED)
     978             :  */
     979             : static void
     980       29814 : reportDependentObjects(const ObjectAddresses *targetObjects,
     981             :                        DropBehavior behavior,
     982             :                        int flags,
     983             :                        const ObjectAddress *origObject)
     984             : {
     985       29814 :     int         msglevel = (flags & PERFORM_DELETION_QUIETLY) ? DEBUG2 : NOTICE;
     986       29814 :     bool        ok = true;
     987             :     StringInfoData clientdetail;
     988             :     StringInfoData logdetail;
     989       29814 :     int         numReportedClient = 0;
     990       29814 :     int         numNotReportedClient = 0;
     991             :     int         i;
     992             : 
     993             :     /*
     994             :      * If we need to delete any partition-dependent objects, make sure that
     995             :      * we're deleting at least one of their partition dependencies, too. That
     996             :      * can be detected by checking that we reached them by a PARTITION
     997             :      * dependency at some point.
     998             :      *
     999             :      * We just report the first such object, as in most cases the only way to
    1000             :      * trigger this complaint is to explicitly try to delete one partition of
    1001             :      * a partitioned object.
    1002             :      */
    1003      209792 :     for (i = 0; i < targetObjects->numrefs; i++)
    1004             :     {
    1005      180008 :         const ObjectAddressExtra *extra = &targetObjects->extras[i];
    1006             : 
    1007      180008 :         if ((extra->flags & DEPFLAG_IS_PART) &&
    1008        4694 :             !(extra->flags & DEPFLAG_PARTITION))
    1009             :         {
    1010          30 :             const ObjectAddress *object = &targetObjects->refs[i];
    1011          30 :             char       *otherObjDesc = getObjectDescription(&extra->dependee,
    1012             :                                                             false);
    1013             : 
    1014          30 :             ereport(ERROR,
    1015             :                     (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
    1016             :                      errmsg("cannot drop %s because %s requires it",
    1017             :                             getObjectDescription(object, false), otherObjDesc),
    1018             :                      errhint("You can drop %s instead.", otherObjDesc)));
    1019             :         }
    1020             :     }
    1021             : 
    1022             :     /*
    1023             :      * If no error is to be thrown, and the msglevel is too low to be shown to
    1024             :      * either client or server log, there's no need to do any of the rest of
    1025             :      * the work.
    1026             :      */
    1027       29784 :     if (behavior == DROP_CASCADE &&
    1028        3164 :         !message_level_is_interesting(msglevel))
    1029         864 :         return;
    1030             : 
    1031             :     /*
    1032             :      * We limit the number of dependencies reported to the client to
    1033             :      * MAX_REPORTED_DEPS, since client software may not deal well with
    1034             :      * enormous error strings.  The server log always gets a full report.
    1035             :      */
    1036             : #define MAX_REPORTED_DEPS 100
    1037             : 
    1038       28920 :     initStringInfo(&clientdetail);
    1039       28920 :     initStringInfo(&logdetail);
    1040             : 
    1041             :     /*
    1042             :      * We process the list back to front (ie, in dependency order not deletion
    1043             :      * order), since this makes for a more understandable display.
    1044             :      */
    1045      197356 :     for (i = targetObjects->numrefs - 1; i >= 0; i--)
    1046             :     {
    1047      168436 :         const ObjectAddress *obj = &targetObjects->refs[i];
    1048      168436 :         const ObjectAddressExtra *extra = &targetObjects->extras[i];
    1049             :         char       *objDesc;
    1050             : 
    1051             :         /* Ignore the original deletion target(s) */
    1052      168436 :         if (extra->flags & DEPFLAG_ORIGINAL)
    1053       33838 :             continue;
    1054             : 
    1055             :         /* Also ignore sub-objects; we'll report the whole object elsewhere */
    1056      134598 :         if (extra->flags & DEPFLAG_SUBOBJECT)
    1057           0 :             continue;
    1058             : 
    1059      134598 :         objDesc = getObjectDescription(obj, false);
    1060             : 
    1061             :         /* An object being dropped concurrently doesn't need to be reported */
    1062      134598 :         if (objDesc == NULL)
    1063           0 :             continue;
    1064             : 
    1065             :         /*
    1066             :          * If, at any stage of the recursive search, we reached the object via
    1067             :          * an AUTO, INTERNAL, PARTITION, or EXTENSION dependency, then it's
    1068             :          * okay to delete it even in RESTRICT mode.
    1069             :          */
    1070      134598 :         if (extra->flags & (DEPFLAG_AUTO |
    1071             :                             DEPFLAG_INTERNAL |
    1072             :                             DEPFLAG_PARTITION |
    1073             :                             DEPFLAG_EXTENSION))
    1074             :         {
    1075             :             /*
    1076             :              * auto-cascades are reported at DEBUG2, not msglevel.  We don't
    1077             :              * try to combine them with the regular message because the
    1078             :              * results are too confusing when client_min_messages and
    1079             :              * log_min_messages are different.
    1080             :              */
    1081      129832 :             ereport(DEBUG2,
    1082             :                     (errmsg_internal("drop auto-cascades to %s",
    1083             :                                      objDesc)));
    1084             :         }
    1085        4766 :         else if (behavior == DROP_RESTRICT)
    1086             :         {
    1087         508 :             char       *otherDesc = getObjectDescription(&extra->dependee,
    1088             :                                                          false);
    1089             : 
    1090         508 :             if (otherDesc)
    1091             :             {
    1092         508 :                 if (numReportedClient < MAX_REPORTED_DEPS)
    1093             :                 {
    1094             :                     /* separate entries with a newline */
    1095         508 :                     if (clientdetail.len != 0)
    1096         206 :                         appendStringInfoChar(&clientdetail, '\n');
    1097         508 :                     appendStringInfo(&clientdetail, _("%s depends on %s"),
    1098             :                                      objDesc, otherDesc);
    1099         508 :                     numReportedClient++;
    1100             :                 }
    1101             :                 else
    1102           0 :                     numNotReportedClient++;
    1103             :                 /* separate entries with a newline */
    1104         508 :                 if (logdetail.len != 0)
    1105         206 :                     appendStringInfoChar(&logdetail, '\n');
    1106         508 :                 appendStringInfo(&logdetail, _("%s depends on %s"),
    1107             :                                  objDesc, otherDesc);
    1108         508 :                 pfree(otherDesc);
    1109             :             }
    1110             :             else
    1111           0 :                 numNotReportedClient++;
    1112         508 :             ok = false;
    1113             :         }
    1114             :         else
    1115             :         {
    1116        4258 :             if (numReportedClient < MAX_REPORTED_DEPS)
    1117             :             {
    1118             :                 /* separate entries with a newline */
    1119        4258 :                 if (clientdetail.len != 0)
    1120        2912 :                     appendStringInfoChar(&clientdetail, '\n');
    1121        4258 :                 appendStringInfo(&clientdetail, _("drop cascades to %s"),
    1122             :                                  objDesc);
    1123        4258 :                 numReportedClient++;
    1124             :             }
    1125             :             else
    1126           0 :                 numNotReportedClient++;
    1127             :             /* separate entries with a newline */
    1128        4258 :             if (logdetail.len != 0)
    1129        2912 :                 appendStringInfoChar(&logdetail, '\n');
    1130        4258 :             appendStringInfo(&logdetail, _("drop cascades to %s"),
    1131             :                              objDesc);
    1132             :         }
    1133             : 
    1134      134598 :         pfree(objDesc);
    1135             :     }
    1136             : 
    1137       28920 :     if (numNotReportedClient > 0)
    1138           0 :         appendStringInfo(&clientdetail, ngettext("\nand %d other object "
    1139             :                                                  "(see server log for list)",
    1140             :                                                  "\nand %d other objects "
    1141             :                                                  "(see server log for list)",
    1142             :                                                  numNotReportedClient),
    1143             :                          numNotReportedClient);
    1144             : 
    1145       28920 :     if (!ok)
    1146             :     {
    1147         302 :         if (origObject)
    1148         296 :             ereport(ERROR,
    1149             :                     (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
    1150             :                      errmsg("cannot drop %s because other objects depend on it",
    1151             :                             getObjectDescription(origObject, false)),
    1152             :                      errdetail_internal("%s", clientdetail.data),
    1153             :                      errdetail_log("%s", logdetail.data),
    1154             :                      errhint("Use DROP ... CASCADE to drop the dependent objects too.")));
    1155             :         else
    1156           6 :             ereport(ERROR,
    1157             :                     (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
    1158             :                      errmsg("cannot drop desired object(s) because other objects depend on them"),
    1159             :                      errdetail_internal("%s", clientdetail.data),
    1160             :                      errdetail_log("%s", logdetail.data),
    1161             :                      errhint("Use DROP ... CASCADE to drop the dependent objects too.")));
    1162             :     }
    1163       28618 :     else if (numReportedClient > 1)
    1164             :     {
    1165         634 :         ereport(msglevel,
    1166             :                 (errmsg_plural("drop cascades to %d other object",
    1167             :                                "drop cascades to %d other objects",
    1168             :                                numReportedClient + numNotReportedClient,
    1169             :                                numReportedClient + numNotReportedClient),
    1170             :                  errdetail_internal("%s", clientdetail.data),
    1171             :                  errdetail_log("%s", logdetail.data)));
    1172             :     }
    1173       27984 :     else if (numReportedClient == 1)
    1174             :     {
    1175             :         /* we just use the single item as-is */
    1176         712 :         ereport(msglevel,
    1177             :                 (errmsg_internal("%s", clientdetail.data)));
    1178             :     }
    1179             : 
    1180       28618 :     pfree(clientdetail.data);
    1181       28618 :     pfree(logdetail.data);
    1182             : }
    1183             : 
    1184             : /*
    1185             :  * Drop an object by OID.  Works for most catalogs, if no special processing
    1186             :  * is needed.
    1187             :  */
    1188             : static void
    1189        3214 : DropObjectById(const ObjectAddress *object)
    1190             : {
    1191             :     int         cacheId;
    1192             :     Relation    rel;
    1193             :     HeapTuple   tup;
    1194             : 
    1195        3214 :     cacheId = get_object_catcache_oid(object->classId);
    1196             : 
    1197        3214 :     rel = table_open(object->classId, RowExclusiveLock);
    1198             : 
    1199             :     /*
    1200             :      * Use the system cache for the oid column, if one exists.
    1201             :      */
    1202        3214 :     if (cacheId >= 0)
    1203             :     {
    1204        1740 :         tup = SearchSysCache1(cacheId, ObjectIdGetDatum(object->objectId));
    1205        1740 :         if (!HeapTupleIsValid(tup))
    1206           0 :             elog(ERROR, "cache lookup failed for %s %u",
    1207             :                  get_object_class_descr(object->classId), object->objectId);
    1208             : 
    1209        1740 :         CatalogTupleDelete(rel, &tup->t_self);
    1210             : 
    1211        1740 :         ReleaseSysCache(tup);
    1212             :     }
    1213             :     else
    1214             :     {
    1215             :         ScanKeyData skey[1];
    1216             :         SysScanDesc scan;
    1217             : 
    1218        2948 :         ScanKeyInit(&skey[0],
    1219        1474 :                     get_object_attnum_oid(object->classId),
    1220             :                     BTEqualStrategyNumber, F_OIDEQ,
    1221             :                     ObjectIdGetDatum(object->objectId));
    1222             : 
    1223        1474 :         scan = systable_beginscan(rel, get_object_oid_index(object->classId), true,
    1224             :                                   NULL, 1, skey);
    1225             : 
    1226             :         /* we expect exactly one match */
    1227        1474 :         tup = systable_getnext(scan);
    1228        1474 :         if (!HeapTupleIsValid(tup))
    1229           0 :             elog(ERROR, "could not find tuple for %s %u",
    1230             :                  get_object_class_descr(object->classId), object->objectId);
    1231             : 
    1232        1474 :         CatalogTupleDelete(rel, &tup->t_self);
    1233             : 
    1234        1474 :         systable_endscan(scan);
    1235             :     }
    1236             : 
    1237        3214 :     table_close(rel, RowExclusiveLock);
    1238        3214 : }
    1239             : 
    1240             : /*
    1241             :  * deleteOneObject: delete a single object for performDeletion.
    1242             :  *
    1243             :  * *depRel is the already-open pg_depend relation.
    1244             :  */
    1245             : static void
    1246      175178 : deleteOneObject(const ObjectAddress *object, Relation *depRel, int flags)
    1247             : {
    1248             :     ScanKeyData key[3];
    1249             :     int         nkeys;
    1250             :     SysScanDesc scan;
    1251             :     HeapTuple   tup;
    1252             : 
    1253             :     /* DROP hook of the objects being removed */
    1254      175178 :     InvokeObjectDropHookArg(object->classId, object->objectId,
    1255             :                             object->objectSubId, flags);
    1256             : 
    1257             :     /*
    1258             :      * Close depRel if we are doing a drop concurrently.  The object deletion
    1259             :      * subroutine will commit the current transaction, so we can't keep the
    1260             :      * relation open across doDeletion().
    1261             :      */
    1262      175178 :     if (flags & PERFORM_DELETION_CONCURRENTLY)
    1263          90 :         table_close(*depRel, RowExclusiveLock);
    1264             : 
    1265             :     /*
    1266             :      * Delete the object itself, in an object-type-dependent way.
    1267             :      *
    1268             :      * We used to do this after removing the outgoing dependency links, but it
    1269             :      * seems just as reasonable to do it beforehand.  In the concurrent case
    1270             :      * we *must* do it in this order, because we can't make any transactional
    1271             :      * updates before calling doDeletion() --- they'd get committed right
    1272             :      * away, which is not cool if the deletion then fails.
    1273             :      */
    1274      175178 :     doDeletion(object, flags);
    1275             : 
    1276             :     /*
    1277             :      * Reopen depRel if we closed it above
    1278             :      */
    1279      175174 :     if (flags & PERFORM_DELETION_CONCURRENTLY)
    1280          90 :         *depRel = table_open(DependRelationId, RowExclusiveLock);
    1281             : 
    1282             :     /*
    1283             :      * Now remove any pg_depend records that link from this object to others.
    1284             :      * (Any records linking to this object should be gone already.)
    1285             :      *
    1286             :      * When dropping a whole object (subId = 0), remove all pg_depend records
    1287             :      * for its sub-objects too.
    1288             :      */
    1289      175174 :     ScanKeyInit(&key[0],
    1290             :                 Anum_pg_depend_classid,
    1291             :                 BTEqualStrategyNumber, F_OIDEQ,
    1292             :                 ObjectIdGetDatum(object->classId));
    1293      175174 :     ScanKeyInit(&key[1],
    1294             :                 Anum_pg_depend_objid,
    1295             :                 BTEqualStrategyNumber, F_OIDEQ,
    1296             :                 ObjectIdGetDatum(object->objectId));
    1297      175174 :     if (object->objectSubId != 0)
    1298             :     {
    1299        1990 :         ScanKeyInit(&key[2],
    1300             :                     Anum_pg_depend_objsubid,
    1301             :                     BTEqualStrategyNumber, F_INT4EQ,
    1302             :                     Int32GetDatum(object->objectSubId));
    1303        1990 :         nkeys = 3;
    1304             :     }
    1305             :     else
    1306      173184 :         nkeys = 2;
    1307             : 
    1308      175174 :     scan = systable_beginscan(*depRel, DependDependerIndexId, true,
    1309             :                               NULL, nkeys, key);
    1310             : 
    1311      423030 :     while (HeapTupleIsValid(tup = systable_getnext(scan)))
    1312             :     {
    1313      247856 :         CatalogTupleDelete(*depRel, &tup->t_self);
    1314             :     }
    1315             : 
    1316      175174 :     systable_endscan(scan);
    1317             : 
    1318             :     /*
    1319             :      * Delete shared dependency references related to this object.  Again, if
    1320             :      * subId = 0, remove records for sub-objects too.
    1321             :      */
    1322      175174 :     deleteSharedDependencyRecordsFor(object->classId, object->objectId,
    1323             :                                      object->objectSubId);
    1324             : 
    1325             : 
    1326             :     /*
    1327             :      * Delete any comments, security labels, or initial privileges associated
    1328             :      * with this object.  (This is a convenient place to do these things,
    1329             :      * rather than having every object type know to do it.)  As above, all
    1330             :      * these functions must remove records for sub-objects too if the subid is
    1331             :      * zero.
    1332             :      */
    1333      175174 :     DeleteComments(object->objectId, object->classId, object->objectSubId);
    1334      175174 :     DeleteSecurityLabel(object);
    1335      175174 :     DeleteInitPrivs(object);
    1336             : 
    1337             :     /*
    1338             :      * CommandCounterIncrement here to ensure that preceding changes are all
    1339             :      * visible to the next deletion step.
    1340             :      */
    1341      175174 :     CommandCounterIncrement();
    1342             : 
    1343             :     /*
    1344             :      * And we're done!
    1345             :      */
    1346      175174 : }
    1347             : 
    1348             : /*
    1349             :  * doDeletion: actually delete a single object
    1350             :  */
    1351             : static void
    1352      175178 : doDeletion(const ObjectAddress *object, int flags)
    1353             : {
    1354      175178 :     switch (object->classId)
    1355             :     {
    1356       66044 :         case RelationRelationId:
    1357             :             {
    1358       66044 :                 char        relKind = get_rel_relkind(object->objectId);
    1359             : 
    1360       66044 :                 if (relKind == RELKIND_INDEX ||
    1361             :                     relKind == RELKIND_PARTITIONED_INDEX)
    1362       22514 :                 {
    1363       22514 :                     bool        concurrent = ((flags & PERFORM_DELETION_CONCURRENTLY) != 0);
    1364       22514 :                     bool        concurrent_lock_mode = ((flags & PERFORM_DELETION_CONCURRENT_LOCK) != 0);
    1365             : 
    1366             :                     Assert(object->objectSubId == 0);
    1367       22514 :                     index_drop(object->objectId, concurrent, concurrent_lock_mode);
    1368             :                 }
    1369             :                 else
    1370             :                 {
    1371       43530 :                     if (object->objectSubId != 0)
    1372        1990 :                         RemoveAttributeById(object->objectId,
    1373        1990 :                                             object->objectSubId);
    1374             :                     else
    1375       41540 :                         heap_drop_with_catalog(object->objectId);
    1376             :                 }
    1377             : 
    1378             :                 /*
    1379             :                  * for a sequence, in addition to dropping the heap, also
    1380             :                  * delete pg_sequence tuple
    1381             :                  */
    1382       66044 :                 if (relKind == RELKIND_SEQUENCE)
    1383         916 :                     DeleteSequenceTuple(object->objectId);
    1384       66044 :                 break;
    1385             :             }
    1386             : 
    1387        6514 :         case ProcedureRelationId:
    1388        6514 :             RemoveFunctionById(object->objectId);
    1389        6514 :             break;
    1390             : 
    1391       64402 :         case TypeRelationId:
    1392       64402 :             RemoveTypeById(object->objectId);
    1393       64402 :             break;
    1394             : 
    1395       12846 :         case ConstraintRelationId:
    1396       12846 :             RemoveConstraintById(object->objectId);
    1397       12844 :             break;
    1398             : 
    1399        2812 :         case AttrDefaultRelationId:
    1400        2812 :             RemoveAttrDefaultById(object->objectId);
    1401        2812 :             break;
    1402             : 
    1403          88 :         case LargeObjectRelationId:
    1404          88 :             LargeObjectDrop(object->objectId);
    1405          88 :             break;
    1406             : 
    1407         734 :         case OperatorRelationId:
    1408         734 :             RemoveOperatorById(object->objectId);
    1409         734 :             break;
    1410             : 
    1411        2828 :         case RewriteRelationId:
    1412        2828 :             RemoveRewriteRuleById(object->objectId);
    1413        2826 :             break;
    1414             : 
    1415       13192 :         case TriggerRelationId:
    1416       13192 :             RemoveTriggerById(object->objectId);
    1417       13192 :             break;
    1418             : 
    1419         478 :         case StatisticExtRelationId:
    1420         478 :             RemoveStatisticsById(object->objectId);
    1421         478 :             break;
    1422             : 
    1423          48 :         case TSConfigRelationId:
    1424          48 :             RemoveTSConfigurationById(object->objectId);
    1425          48 :             break;
    1426             : 
    1427         110 :         case ExtensionRelationId:
    1428         110 :             RemoveExtensionById(object->objectId);
    1429         110 :             break;
    1430             : 
    1431         540 :         case PolicyRelationId:
    1432         540 :             RemovePolicyById(object->objectId);
    1433         540 :             break;
    1434             : 
    1435         192 :         case PublicationNamespaceRelationId:
    1436         192 :             RemovePublicationSchemaById(object->objectId);
    1437         192 :             break;
    1438             : 
    1439         766 :         case PublicationRelRelationId:
    1440         766 :             RemovePublicationRelById(object->objectId);
    1441         766 :             break;
    1442             : 
    1443         370 :         case PublicationRelationId:
    1444         370 :             RemovePublicationById(object->objectId);
    1445         370 :             break;
    1446             : 
    1447        3214 :         case CastRelationId:
    1448             :         case CollationRelationId:
    1449             :         case ConversionRelationId:
    1450             :         case LanguageRelationId:
    1451             :         case OperatorClassRelationId:
    1452             :         case OperatorFamilyRelationId:
    1453             :         case AccessMethodRelationId:
    1454             :         case AccessMethodOperatorRelationId:
    1455             :         case AccessMethodProcedureRelationId:
    1456             :         case NamespaceRelationId:
    1457             :         case TSParserRelationId:
    1458             :         case TSDictionaryRelationId:
    1459             :         case TSTemplateRelationId:
    1460             :         case ForeignDataWrapperRelationId:
    1461             :         case ForeignServerRelationId:
    1462             :         case UserMappingRelationId:
    1463             :         case DefaultAclRelationId:
    1464             :         case EventTriggerRelationId:
    1465             :         case TransformRelationId:
    1466             :         case AuthMemRelationId:
    1467        3214 :             DropObjectById(object);
    1468        3214 :             break;
    1469             : 
    1470             :             /*
    1471             :              * These global object types are not supported here.
    1472             :              */
    1473           0 :         case AuthIdRelationId:
    1474             :         case DatabaseRelationId:
    1475             :         case TableSpaceRelationId:
    1476             :         case SubscriptionRelationId:
    1477             :         case ParameterAclRelationId:
    1478           0 :             elog(ERROR, "global objects cannot be deleted by doDeletion");
    1479             :             break;
    1480             : 
    1481           0 :         default:
    1482           0 :             elog(ERROR, "unsupported object class: %u", object->classId);
    1483             :     }
    1484      175174 : }
    1485             : 
    1486             : /*
    1487             :  * AcquireDeletionLock - acquire a suitable lock for deleting an object
    1488             :  *
    1489             :  * Accepts the same flags as performDeletion (though currently only
    1490             :  * PERFORM_DELETION_CONCURRENTLY does anything).
    1491             :  *
    1492             :  * We use LockRelation for relations, and otherwise LockSharedObject or
    1493             :  * LockDatabaseObject as appropriate for the object type.
    1494             :  */
    1495             : void
    1496      223546 : AcquireDeletionLock(const ObjectAddress *object, int flags)
    1497             : {
    1498      223546 :     if (object->classId == RelationRelationId)
    1499             :     {
    1500             :         /*
    1501             :          * In DROP INDEX CONCURRENTLY, take only ShareUpdateExclusiveLock on
    1502             :          * the index for the moment.  index_drop() will promote the lock once
    1503             :          * it's safe to do so.  In all other cases we need full exclusive
    1504             :          * lock.
    1505             :          */
    1506       83964 :         if (flags & PERFORM_DELETION_CONCURRENTLY)
    1507          90 :             LockRelationOid(object->objectId, ShareUpdateExclusiveLock);
    1508             :         else
    1509       83874 :             LockRelationOid(object->objectId, AccessExclusiveLock);
    1510             :     }
    1511      139582 :     else if (object->classId == AuthMemRelationId)
    1512          12 :         LockSharedObject(object->classId, object->objectId, 0,
    1513             :                          AccessExclusiveLock);
    1514             :     else
    1515             :     {
    1516             :         /* assume we should lock the whole object not a sub-object */
    1517      139570 :         LockDatabaseObject(object->classId, object->objectId, 0,
    1518             :                            AccessExclusiveLock);
    1519             :     }
    1520      223546 : }
    1521             : 
    1522             : /*
    1523             :  * ReleaseDeletionLock - release an object deletion lock
    1524             :  *
    1525             :  * Companion to AcquireDeletionLock.
    1526             :  */
    1527             : void
    1528        1520 : ReleaseDeletionLock(const ObjectAddress *object)
    1529             : {
    1530        1520 :     if (object->classId == RelationRelationId)
    1531          56 :         UnlockRelationOid(object->objectId, AccessExclusiveLock);
    1532             :     else
    1533             :         /* assume we should lock the whole object not a sub-object */
    1534        1464 :         UnlockDatabaseObject(object->classId, object->objectId, 0,
    1535             :                              AccessExclusiveLock);
    1536        1520 : }
    1537             : 
    1538             : /*
    1539             :  * recordDependencyOnExpr - find expression dependencies
    1540             :  *
    1541             :  * This is used to find the dependencies of rules, constraint expressions,
    1542             :  * etc.
    1543             :  *
    1544             :  * Given an expression or query in node-tree form, find all the objects
    1545             :  * it refers to (tables, columns, operators, functions, etc).  Record
    1546             :  * a dependency of the specified type from the given depender object
    1547             :  * to each object mentioned in the expression.
    1548             :  *
    1549             :  * rtable is the rangetable to be used to interpret Vars with varlevelsup=0.
    1550             :  * It can be NIL if no such variables are expected.
    1551             :  */
    1552             : void
    1553       26790 : recordDependencyOnExpr(const ObjectAddress *depender,
    1554             :                        Node *expr, List *rtable,
    1555             :                        DependencyType behavior)
    1556             : {
    1557             :     find_expr_references_context context;
    1558             : 
    1559       26790 :     context.addrs = new_object_addresses();
    1560             : 
    1561             :     /* Set up interpretation for Vars at varlevelsup = 0 */
    1562       26790 :     context.rtables = list_make1(rtable);
    1563             : 
    1564             :     /* Scan the expression tree for referenceable objects */
    1565       26790 :     find_expr_references_walker(expr, &context);
    1566             : 
    1567             :     /* Remove any duplicates */
    1568       26790 :     eliminate_duplicate_dependencies(context.addrs);
    1569             : 
    1570             :     /* And record 'em */
    1571       26790 :     recordMultipleDependencies(depender,
    1572       26790 :                                context.addrs->refs, context.addrs->numrefs,
    1573             :                                behavior);
    1574             : 
    1575       26790 :     free_object_addresses(context.addrs);
    1576       26790 : }
    1577             : 
    1578             : /*
    1579             :  * recordDependencyOnSingleRelExpr - find expression dependencies
    1580             :  *
    1581             :  * As above, but only one relation is expected to be referenced (with
    1582             :  * varno = 1 and varlevelsup = 0).  Pass the relation OID instead of a
    1583             :  * range table.  An additional frammish is that dependencies on that
    1584             :  * relation's component columns will be marked with 'self_behavior',
    1585             :  * whereas 'behavior' is used for everything else; also, if 'reverse_self'
    1586             :  * is true, those dependencies are reversed so that the columns are made
    1587             :  * to depend on the table not vice versa.
    1588             :  *
    1589             :  * NOTE: the caller should ensure that a whole-table dependency on the
    1590             :  * specified relation is created separately, if one is needed.  In particular,
    1591             :  * a whole-row Var "relation.*" will not cause this routine to emit any
    1592             :  * dependency item.  This is appropriate behavior for subexpressions of an
    1593             :  * ordinary query, so other cases need to cope as necessary.
    1594             :  */
    1595             : void
    1596        8442 : recordDependencyOnSingleRelExpr(const ObjectAddress *depender,
    1597             :                                 Node *expr, Oid relId,
    1598             :                                 DependencyType behavior,
    1599             :                                 DependencyType self_behavior,
    1600             :                                 bool reverse_self)
    1601             : {
    1602             :     find_expr_references_context context;
    1603        8442 :     RangeTblEntry rte = {0};
    1604             : 
    1605        8442 :     context.addrs = new_object_addresses();
    1606             : 
    1607             :     /* We gin up a rather bogus rangetable list to handle Vars */
    1608        8442 :     rte.type = T_RangeTblEntry;
    1609        8442 :     rte.rtekind = RTE_RELATION;
    1610        8442 :     rte.relid = relId;
    1611        8442 :     rte.relkind = RELKIND_RELATION; /* no need for exactness here */
    1612        8442 :     rte.rellockmode = AccessShareLock;
    1613             : 
    1614        8442 :     context.rtables = list_make1(list_make1(&rte));
    1615             : 
    1616             :     /* Scan the expression tree for referenceable objects */
    1617        8442 :     find_expr_references_walker(expr, &context);
    1618             : 
    1619             :     /* Remove any duplicates */
    1620        8442 :     eliminate_duplicate_dependencies(context.addrs);
    1621             : 
    1622             :     /* Separate self-dependencies if necessary */
    1623        8442 :     if ((behavior != self_behavior || reverse_self) &&
    1624        1698 :         context.addrs->numrefs > 0)
    1625             :     {
    1626             :         ObjectAddresses *self_addrs;
    1627             :         ObjectAddress *outobj;
    1628             :         int         oldref,
    1629             :                     outrefs;
    1630             : 
    1631        1692 :         self_addrs = new_object_addresses();
    1632             : 
    1633        1692 :         outobj = context.addrs->refs;
    1634        1692 :         outrefs = 0;
    1635        7072 :         for (oldref = 0; oldref < context.addrs->numrefs; oldref++)
    1636             :         {
    1637        5380 :             ObjectAddress *thisobj = context.addrs->refs + oldref;
    1638             : 
    1639        5380 :             if (thisobj->classId == RelationRelationId &&
    1640        2140 :                 thisobj->objectId == relId)
    1641             :             {
    1642             :                 /* Move this ref into self_addrs */
    1643        2128 :                 add_exact_object_address(thisobj, self_addrs);
    1644             :             }
    1645             :             else
    1646             :             {
    1647             :                 /* Keep it in context.addrs */
    1648        3252 :                 *outobj = *thisobj;
    1649        3252 :                 outobj++;
    1650        3252 :                 outrefs++;
    1651             :             }
    1652             :         }
    1653        1692 :         context.addrs->numrefs = outrefs;
    1654             : 
    1655             :         /* Record the self-dependencies with the appropriate direction */
    1656        1692 :         if (!reverse_self)
    1657        1484 :             recordMultipleDependencies(depender,
    1658        1484 :                                        self_addrs->refs, self_addrs->numrefs,
    1659             :                                        self_behavior);
    1660             :         else
    1661             :         {
    1662             :             /* Can't use recordMultipleDependencies, so do it the hard way */
    1663             :             int         selfref;
    1664             : 
    1665         498 :             for (selfref = 0; selfref < self_addrs->numrefs; selfref++)
    1666             :             {
    1667         290 :                 ObjectAddress *thisobj = self_addrs->refs + selfref;
    1668             : 
    1669         290 :                 recordDependencyOn(thisobj, depender, self_behavior);
    1670             :             }
    1671             :         }
    1672             : 
    1673        1692 :         free_object_addresses(self_addrs);
    1674             :     }
    1675             : 
    1676             :     /* Record the external dependencies */
    1677        8442 :     recordMultipleDependencies(depender,
    1678        8442 :                                context.addrs->refs, context.addrs->numrefs,
    1679             :                                behavior);
    1680             : 
    1681        8442 :     free_object_addresses(context.addrs);
    1682        8442 : }
    1683             : 
    1684             : /*
    1685             :  * Recursively search an expression tree for object references.
    1686             :  *
    1687             :  * Note: in many cases we do not need to create dependencies on the datatypes
    1688             :  * involved in an expression, because we'll have an indirect dependency via
    1689             :  * some other object.  For instance Var nodes depend on a column which depends
    1690             :  * on the datatype, and OpExpr nodes depend on the operator which depends on
    1691             :  * the datatype.  However we do need a type dependency if there is no such
    1692             :  * indirect dependency, as for example in Const and CoerceToDomain nodes.
    1693             :  *
    1694             :  * Similarly, we don't need to create dependencies on collations except where
    1695             :  * the collation is being freshly introduced to the expression.
    1696             :  */
    1697             : static bool
    1698     1810884 : find_expr_references_walker(Node *node,
    1699             :                             find_expr_references_context *context)
    1700             : {
    1701     1810884 :     if (node == NULL)
    1702      623748 :         return false;
    1703     1187136 :     if (IsA(node, Var))
    1704             :     {
    1705      289516 :         Var        *var = (Var *) node;
    1706             :         List       *rtable;
    1707             :         RangeTblEntry *rte;
    1708             : 
    1709             :         /* Find matching rtable entry, or complain if not found */
    1710      289516 :         if (var->varlevelsup >= list_length(context->rtables))
    1711           0 :             elog(ERROR, "invalid varlevelsup %d", var->varlevelsup);
    1712      289516 :         rtable = (List *) list_nth(context->rtables, var->varlevelsup);
    1713      289516 :         if (var->varno <= 0 || var->varno > list_length(rtable))
    1714           0 :             elog(ERROR, "invalid varno %d", var->varno);
    1715      289516 :         rte = rt_fetch(var->varno, rtable);
    1716             : 
    1717             :         /*
    1718             :          * A whole-row Var references no specific columns, so adds no new
    1719             :          * dependency.  (We assume that there is a whole-table dependency
    1720             :          * arising from each underlying rangetable entry.  While we could
    1721             :          * record such a dependency when finding a whole-row Var that
    1722             :          * references a relation directly, it's quite unclear how to extend
    1723             :          * that to whole-row Vars for JOINs, so it seems better to leave the
    1724             :          * responsibility with the range table.  Note that this poses some
    1725             :          * risks for identifying dependencies of stand-alone expressions:
    1726             :          * whole-table references may need to be created separately.)
    1727             :          */
    1728      289516 :         if (var->varattno == InvalidAttrNumber)
    1729        4974 :             return false;
    1730      284542 :         if (rte->rtekind == RTE_RELATION)
    1731             :         {
    1732             :             /* If it's a plain relation, reference this column */
    1733      207482 :             add_object_address(RelationRelationId, rte->relid, var->varattno,
    1734             :                                context->addrs);
    1735             :         }
    1736       77060 :         else if (rte->rtekind == RTE_FUNCTION)
    1737             :         {
    1738             :             /* Might need to add a dependency on a composite type's column */
    1739             :             /* (done out of line, because it's a bit bulky) */
    1740       37778 :             process_function_rte_ref(rte, var->varattno, context);
    1741             :         }
    1742             : 
    1743             :         /*
    1744             :          * Vars referencing other RTE types require no additional work.  In
    1745             :          * particular, a join alias Var can be ignored, because it must
    1746             :          * reference a merged USING column.  The relevant join input columns
    1747             :          * will also be referenced in the join qual, and any type coercion
    1748             :          * functions involved in the alias expression will be dealt with when
    1749             :          * we scan the RTE itself.
    1750             :          */
    1751      284542 :         return false;
    1752             :     }
    1753      897620 :     else if (IsA(node, Const))
    1754             :     {
    1755      149098 :         Const      *con = (Const *) node;
    1756             :         Oid         objoid;
    1757             : 
    1758             :         /* A constant must depend on the constant's datatype */
    1759      149098 :         add_object_address(TypeRelationId, con->consttype, 0,
    1760             :                            context->addrs);
    1761             : 
    1762             :         /*
    1763             :          * We must also depend on the constant's collation: it could be
    1764             :          * different from the datatype's, if a CollateExpr was const-folded to
    1765             :          * a simple constant.  However we can save work in the most common
    1766             :          * case where the collation is "default", since we know that's pinned.
    1767             :          */
    1768      149098 :         if (OidIsValid(con->constcollid) &&
    1769       58508 :             con->constcollid != DEFAULT_COLLATION_OID)
    1770       14116 :             add_object_address(CollationRelationId, con->constcollid, 0,
    1771             :                                context->addrs);
    1772             : 
    1773             :         /*
    1774             :          * If it's a regclass or similar literal referring to an existing
    1775             :          * object, add a reference to that object.  (Currently, only the
    1776             :          * regclass and regconfig cases have any likely use, but we may as
    1777             :          * well handle all the OID-alias datatypes consistently.)
    1778             :          */
    1779      149098 :         if (!con->constisnull)
    1780             :         {
    1781      125272 :             switch (con->consttype)
    1782             :             {
    1783           0 :                 case REGPROCOID:
    1784             :                 case REGPROCEDUREOID:
    1785           0 :                     objoid = DatumGetObjectId(con->constvalue);
    1786           0 :                     if (SearchSysCacheExists1(PROCOID,
    1787             :                                               ObjectIdGetDatum(objoid)))
    1788           0 :                         add_object_address(ProcedureRelationId, objoid, 0,
    1789             :                                            context->addrs);
    1790           0 :                     break;
    1791           0 :                 case REGOPEROID:
    1792             :                 case REGOPERATOROID:
    1793           0 :                     objoid = DatumGetObjectId(con->constvalue);
    1794           0 :                     if (SearchSysCacheExists1(OPEROID,
    1795             :                                               ObjectIdGetDatum(objoid)))
    1796           0 :                         add_object_address(OperatorRelationId, objoid, 0,
    1797             :                                            context->addrs);
    1798           0 :                     break;
    1799        3972 :                 case REGCLASSOID:
    1800        3972 :                     objoid = DatumGetObjectId(con->constvalue);
    1801        3972 :                     if (SearchSysCacheExists1(RELOID,
    1802             :                                               ObjectIdGetDatum(objoid)))
    1803        3972 :                         add_object_address(RelationRelationId, objoid, 0,
    1804             :                                            context->addrs);
    1805        3972 :                     break;
    1806           0 :                 case REGTYPEOID:
    1807           0 :                     objoid = DatumGetObjectId(con->constvalue);
    1808           0 :                     if (SearchSysCacheExists1(TYPEOID,
    1809             :                                               ObjectIdGetDatum(objoid)))
    1810           0 :                         add_object_address(TypeRelationId, objoid, 0,
    1811             :                                            context->addrs);
    1812           0 :                     break;
    1813           0 :                 case REGCOLLATIONOID:
    1814           0 :                     objoid = DatumGetObjectId(con->constvalue);
    1815           0 :                     if (SearchSysCacheExists1(COLLOID,
    1816             :                                               ObjectIdGetDatum(objoid)))
    1817           0 :                         add_object_address(CollationRelationId, objoid, 0,
    1818             :                                            context->addrs);
    1819           0 :                     break;
    1820           0 :                 case REGCONFIGOID:
    1821           0 :                     objoid = DatumGetObjectId(con->constvalue);
    1822           0 :                     if (SearchSysCacheExists1(TSCONFIGOID,
    1823             :                                               ObjectIdGetDatum(objoid)))
    1824           0 :                         add_object_address(TSConfigRelationId, objoid, 0,
    1825             :                                            context->addrs);
    1826           0 :                     break;
    1827           0 :                 case REGDICTIONARYOID:
    1828           0 :                     objoid = DatumGetObjectId(con->constvalue);
    1829           0 :                     if (SearchSysCacheExists1(TSDICTOID,
    1830             :                                               ObjectIdGetDatum(objoid)))
    1831           0 :                         add_object_address(TSDictionaryRelationId, objoid, 0,
    1832             :                                            context->addrs);
    1833           0 :                     break;
    1834             : 
    1835         172 :                 case REGNAMESPACEOID:
    1836         172 :                     objoid = DatumGetObjectId(con->constvalue);
    1837         172 :                     if (SearchSysCacheExists1(NAMESPACEOID,
    1838             :                                               ObjectIdGetDatum(objoid)))
    1839         172 :                         add_object_address(NamespaceRelationId, objoid, 0,
    1840             :                                            context->addrs);
    1841         172 :                     break;
    1842             : 
    1843             :                     /*
    1844             :                      * Dependencies for regrole should be shared among all
    1845             :                      * databases, so explicitly inhibit to have dependencies.
    1846             :                      */
    1847           0 :                 case REGROLEOID:
    1848           0 :                     ereport(ERROR,
    1849             :                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1850             :                              errmsg("constant of the type %s cannot be used here",
    1851             :                                     "regrole")));
    1852             :                     break;
    1853             :             }
    1854       23826 :         }
    1855      149098 :         return false;
    1856             :     }
    1857      748522 :     else if (IsA(node, Param))
    1858             :     {
    1859       14232 :         Param      *param = (Param *) node;
    1860             : 
    1861             :         /* A parameter must depend on the parameter's datatype */
    1862       14232 :         add_object_address(TypeRelationId, param->paramtype, 0,
    1863             :                            context->addrs);
    1864             :         /* and its collation, just as for Consts */
    1865       14232 :         if (OidIsValid(param->paramcollid) &&
    1866        2366 :             param->paramcollid != DEFAULT_COLLATION_OID)
    1867        1376 :             add_object_address(CollationRelationId, param->paramcollid, 0,
    1868             :                                context->addrs);
    1869             :     }
    1870      734290 :     else if (IsA(node, FuncExpr))
    1871             :     {
    1872       72520 :         FuncExpr   *funcexpr = (FuncExpr *) node;
    1873             : 
    1874       72520 :         add_object_address(ProcedureRelationId, funcexpr->funcid, 0,
    1875             :                            context->addrs);
    1876             :         /* fall through to examine arguments */
    1877             :     }
    1878      661770 :     else if (IsA(node, OpExpr))
    1879             :     {
    1880       83052 :         OpExpr     *opexpr = (OpExpr *) node;
    1881             : 
    1882       83052 :         add_object_address(OperatorRelationId, opexpr->opno, 0,
    1883             :                            context->addrs);
    1884             :         /* fall through to examine arguments */
    1885             :     }
    1886      578718 :     else if (IsA(node, DistinctExpr))
    1887             :     {
    1888          12 :         DistinctExpr *distinctexpr = (DistinctExpr *) node;
    1889             : 
    1890          12 :         add_object_address(OperatorRelationId, distinctexpr->opno, 0,
    1891             :                            context->addrs);
    1892             :         /* fall through to examine arguments */
    1893             :     }
    1894      578706 :     else if (IsA(node, NullIfExpr))
    1895             :     {
    1896         114 :         NullIfExpr *nullifexpr = (NullIfExpr *) node;
    1897             : 
    1898         114 :         add_object_address(OperatorRelationId, nullifexpr->opno, 0,
    1899             :                            context->addrs);
    1900             :         /* fall through to examine arguments */
    1901             :     }
    1902      578592 :     else if (IsA(node, ScalarArrayOpExpr))
    1903             :     {
    1904        6104 :         ScalarArrayOpExpr *opexpr = (ScalarArrayOpExpr *) node;
    1905             : 
    1906        6104 :         add_object_address(OperatorRelationId, opexpr->opno, 0,
    1907             :                            context->addrs);
    1908             :         /* fall through to examine arguments */
    1909             :     }
    1910      572488 :     else if (IsA(node, Aggref))
    1911             :     {
    1912        1628 :         Aggref     *aggref = (Aggref *) node;
    1913             : 
    1914        1628 :         add_object_address(ProcedureRelationId, aggref->aggfnoid, 0,
    1915             :                            context->addrs);
    1916             :         /* fall through to examine arguments */
    1917             :     }
    1918      570860 :     else if (IsA(node, WindowFunc))
    1919             :     {
    1920         146 :         WindowFunc *wfunc = (WindowFunc *) node;
    1921             : 
    1922         146 :         add_object_address(ProcedureRelationId, wfunc->winfnoid, 0,
    1923             :                            context->addrs);
    1924             :         /* fall through to examine arguments */
    1925             :     }
    1926      570714 :     else if (IsA(node, SubscriptingRef))
    1927             :     {
    1928        2302 :         SubscriptingRef *sbsref = (SubscriptingRef *) node;
    1929             : 
    1930             :         /*
    1931             :          * The refexpr should provide adequate dependency on refcontainertype,
    1932             :          * and that type in turn depends on refelemtype.  However, a custom
    1933             :          * subscripting handler might set refrestype to something different
    1934             :          * from either of those, in which case we'd better record it.
    1935             :          */
    1936        2302 :         if (sbsref->refrestype != sbsref->refcontainertype &&
    1937        2176 :             sbsref->refrestype != sbsref->refelemtype)
    1938           0 :             add_object_address(TypeRelationId, sbsref->refrestype, 0,
    1939             :                                context->addrs);
    1940             :         /* fall through to examine arguments */
    1941             :     }
    1942      568412 :     else if (IsA(node, SubPlan))
    1943             :     {
    1944             :         /* Extra work needed here if we ever need this case */
    1945           0 :         elog(ERROR, "already-planned subqueries not supported");
    1946             :     }
    1947      568412 :     else if (IsA(node, FieldSelect))
    1948             :     {
    1949       12440 :         FieldSelect *fselect = (FieldSelect *) node;
    1950       12440 :         Oid         argtype = getBaseType(exprType((Node *) fselect->arg));
    1951       12440 :         Oid         reltype = get_typ_typrelid(argtype);
    1952             : 
    1953             :         /*
    1954             :          * We need a dependency on the specific column named in FieldSelect,
    1955             :          * assuming we can identify the pg_class OID for it.  (Probably we
    1956             :          * always can at the moment, but in future it might be possible for
    1957             :          * argtype to be RECORDOID.)  If we can make a column dependency then
    1958             :          * we shouldn't need a dependency on the column's type; but if we
    1959             :          * can't, make a dependency on the type, as it might not appear
    1960             :          * anywhere else in the expression.
    1961             :          */
    1962       12440 :         if (OidIsValid(reltype))
    1963        6986 :             add_object_address(RelationRelationId, reltype, fselect->fieldnum,
    1964             :                                context->addrs);
    1965             :         else
    1966        5454 :             add_object_address(TypeRelationId, fselect->resulttype, 0,
    1967             :                                context->addrs);
    1968             :         /* the collation might not be referenced anywhere else, either */
    1969       12440 :         if (OidIsValid(fselect->resultcollid) &&
    1970        1484 :             fselect->resultcollid != DEFAULT_COLLATION_OID)
    1971           0 :             add_object_address(CollationRelationId, fselect->resultcollid, 0,
    1972             :                                context->addrs);
    1973             :     }
    1974      555972 :     else if (IsA(node, FieldStore))
    1975             :     {
    1976          96 :         FieldStore *fstore = (FieldStore *) node;
    1977          96 :         Oid         reltype = get_typ_typrelid(fstore->resulttype);
    1978             : 
    1979             :         /* similar considerations to FieldSelect, but multiple column(s) */
    1980          96 :         if (OidIsValid(reltype))
    1981             :         {
    1982             :             ListCell   *l;
    1983             : 
    1984         192 :             foreach(l, fstore->fieldnums)
    1985          96 :                 add_object_address(RelationRelationId, reltype, lfirst_int(l),
    1986             :                                    context->addrs);
    1987             :         }
    1988             :         else
    1989           0 :             add_object_address(TypeRelationId, fstore->resulttype, 0,
    1990             :                                context->addrs);
    1991             :     }
    1992      555876 :     else if (IsA(node, RelabelType))
    1993             :     {
    1994       12412 :         RelabelType *relab = (RelabelType *) node;
    1995             : 
    1996             :         /* since there is no function dependency, need to depend on type */
    1997       12412 :         add_object_address(TypeRelationId, relab->resulttype, 0,
    1998             :                            context->addrs);
    1999             :         /* the collation might not be referenced anywhere else, either */
    2000       12412 :         if (OidIsValid(relab->resultcollid) &&
    2001        2764 :             relab->resultcollid != DEFAULT_COLLATION_OID)
    2002        2494 :             add_object_address(CollationRelationId, relab->resultcollid, 0,
    2003             :                                context->addrs);
    2004             :     }
    2005      543464 :     else if (IsA(node, CoerceViaIO))
    2006             :     {
    2007        2576 :         CoerceViaIO *iocoerce = (CoerceViaIO *) node;
    2008             : 
    2009             :         /* since there is no exposed function, need to depend on type */
    2010        2576 :         add_object_address(TypeRelationId, iocoerce->resulttype, 0,
    2011             :                            context->addrs);
    2012             :         /* the collation might not be referenced anywhere else, either */
    2013        2576 :         if (OidIsValid(iocoerce->resultcollid) &&
    2014        2130 :             iocoerce->resultcollid != DEFAULT_COLLATION_OID)
    2015         602 :             add_object_address(CollationRelationId, iocoerce->resultcollid, 0,
    2016             :                                context->addrs);
    2017             :     }
    2018      540888 :     else if (IsA(node, ArrayCoerceExpr))
    2019             :     {
    2020         436 :         ArrayCoerceExpr *acoerce = (ArrayCoerceExpr *) node;
    2021             : 
    2022             :         /* as above, depend on type */
    2023         436 :         add_object_address(TypeRelationId, acoerce->resulttype, 0,
    2024             :                            context->addrs);
    2025             :         /* the collation might not be referenced anywhere else, either */
    2026         436 :         if (OidIsValid(acoerce->resultcollid) &&
    2027         178 :             acoerce->resultcollid != DEFAULT_COLLATION_OID)
    2028          86 :             add_object_address(CollationRelationId, acoerce->resultcollid, 0,
    2029             :                                context->addrs);
    2030             :         /* fall through to examine arguments */
    2031             :     }
    2032      540452 :     else if (IsA(node, ConvertRowtypeExpr))
    2033             :     {
    2034           0 :         ConvertRowtypeExpr *cvt = (ConvertRowtypeExpr *) node;
    2035             : 
    2036             :         /* since there is no function dependency, need to depend on type */
    2037           0 :         add_object_address(TypeRelationId, cvt->resulttype, 0,
    2038             :                            context->addrs);
    2039             :     }
    2040      540452 :     else if (IsA(node, CollateExpr))
    2041             :     {
    2042          84 :         CollateExpr *coll = (CollateExpr *) node;
    2043             : 
    2044          84 :         add_object_address(CollationRelationId, coll->collOid, 0,
    2045             :                            context->addrs);
    2046             :     }
    2047      540368 :     else if (IsA(node, RowExpr))
    2048             :     {
    2049          60 :         RowExpr    *rowexpr = (RowExpr *) node;
    2050             : 
    2051          60 :         add_object_address(TypeRelationId, rowexpr->row_typeid, 0,
    2052             :                            context->addrs);
    2053             :     }
    2054      540308 :     else if (IsA(node, RowCompareExpr))
    2055             :     {
    2056          18 :         RowCompareExpr *rcexpr = (RowCompareExpr *) node;
    2057             :         ListCell   *l;
    2058             : 
    2059          54 :         foreach(l, rcexpr->opnos)
    2060             :         {
    2061          36 :             add_object_address(OperatorRelationId, lfirst_oid(l), 0,
    2062             :                                context->addrs);
    2063             :         }
    2064          54 :         foreach(l, rcexpr->opfamilies)
    2065             :         {
    2066          36 :             add_object_address(OperatorFamilyRelationId, lfirst_oid(l), 0,
    2067             :                                context->addrs);
    2068             :         }
    2069             :         /* fall through to examine arguments */
    2070             :     }
    2071      540290 :     else if (IsA(node, CoerceToDomain))
    2072             :     {
    2073       55662 :         CoerceToDomain *cd = (CoerceToDomain *) node;
    2074             : 
    2075       55662 :         add_object_address(TypeRelationId, cd->resulttype, 0,
    2076             :                            context->addrs);
    2077             :     }
    2078      484628 :     else if (IsA(node, NextValueExpr))
    2079             :     {
    2080           0 :         NextValueExpr *nve = (NextValueExpr *) node;
    2081             : 
    2082           0 :         add_object_address(RelationRelationId, nve->seqid, 0,
    2083             :                            context->addrs);
    2084             :     }
    2085      484628 :     else if (IsA(node, OnConflictExpr))
    2086             :     {
    2087          18 :         OnConflictExpr *onconflict = (OnConflictExpr *) node;
    2088             : 
    2089          18 :         if (OidIsValid(onconflict->constraint))
    2090           0 :             add_object_address(ConstraintRelationId, onconflict->constraint, 0,
    2091             :                                context->addrs);
    2092             :         /* fall through to examine arguments */
    2093             :     }
    2094      484610 :     else if (IsA(node, SortGroupClause))
    2095             :     {
    2096       11244 :         SortGroupClause *sgc = (SortGroupClause *) node;
    2097             : 
    2098       11244 :         add_object_address(OperatorRelationId, sgc->eqop, 0,
    2099             :                            context->addrs);
    2100       11244 :         if (OidIsValid(sgc->sortop))
    2101       11244 :             add_object_address(OperatorRelationId, sgc->sortop, 0,
    2102             :                                context->addrs);
    2103       11244 :         return false;
    2104             :     }
    2105      473366 :     else if (IsA(node, WindowClause))
    2106             :     {
    2107         146 :         WindowClause *wc = (WindowClause *) node;
    2108             : 
    2109         146 :         if (OidIsValid(wc->startInRangeFunc))
    2110           6 :             add_object_address(ProcedureRelationId, wc->startInRangeFunc, 0,
    2111             :                                context->addrs);
    2112         146 :         if (OidIsValid(wc->endInRangeFunc))
    2113           6 :             add_object_address(ProcedureRelationId, wc->endInRangeFunc, 0,
    2114             :                                context->addrs);
    2115         146 :         if (OidIsValid(wc->inRangeColl) &&
    2116           0 :             wc->inRangeColl != DEFAULT_COLLATION_OID)
    2117           0 :             add_object_address(CollationRelationId, wc->inRangeColl, 0,
    2118             :                                context->addrs);
    2119             :         /* fall through to examine substructure */
    2120             :     }
    2121      473220 :     else if (IsA(node, CTECycleClause))
    2122             :     {
    2123          12 :         CTECycleClause *cc = (CTECycleClause *) node;
    2124             : 
    2125          12 :         if (OidIsValid(cc->cycle_mark_type))
    2126          12 :             add_object_address(TypeRelationId, cc->cycle_mark_type, 0,
    2127             :                                context->addrs);
    2128          12 :         if (OidIsValid(cc->cycle_mark_collation))
    2129           6 :             add_object_address(CollationRelationId, cc->cycle_mark_collation, 0,
    2130             :                                context->addrs);
    2131          12 :         if (OidIsValid(cc->cycle_mark_neop))
    2132          12 :             add_object_address(OperatorRelationId, cc->cycle_mark_neop, 0,
    2133             :                                context->addrs);
    2134             :         /* fall through to examine substructure */
    2135             :     }
    2136      473208 :     else if (IsA(node, Query))
    2137             :     {
    2138             :         /* Recurse into RTE subquery or not-yet-planned sublink subquery */
    2139       33522 :         Query      *query = (Query *) node;
    2140             :         ListCell   *lc;
    2141             :         bool        result;
    2142             : 
    2143             :         /*
    2144             :          * Add whole-relation refs for each plain relation mentioned in the
    2145             :          * subquery's rtable, and ensure we add refs for any type-coercion
    2146             :          * functions used in join alias lists.
    2147             :          *
    2148             :          * Note: query_tree_walker takes care of recursing into RTE_FUNCTION
    2149             :          * RTEs, subqueries, etc, so no need to do that here.  But we must
    2150             :          * tell it not to visit join alias lists, or we'll add refs for join
    2151             :          * input columns whether or not they are actually used in our query.
    2152             :          *
    2153             :          * Note: we don't need to worry about collations mentioned in
    2154             :          * RTE_VALUES or RTE_CTE RTEs, because those must just duplicate
    2155             :          * collations referenced in other parts of the Query.  We do have to
    2156             :          * worry about collations mentioned in RTE_FUNCTION, but we take care
    2157             :          * of those when we recurse to the RangeTblFunction node(s).
    2158             :          */
    2159      105808 :         foreach(lc, query->rtable)
    2160             :         {
    2161       72286 :             RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
    2162             : 
    2163       72286 :             switch (rte->rtekind)
    2164             :             {
    2165       45578 :                 case RTE_RELATION:
    2166       45578 :                     add_object_address(RelationRelationId, rte->relid, 0,
    2167             :                                        context->addrs);
    2168       45578 :                     break;
    2169       13066 :                 case RTE_JOIN:
    2170             : 
    2171             :                     /*
    2172             :                      * Examine joinaliasvars entries only for merged JOIN
    2173             :                      * USING columns.  Only those entries could contain
    2174             :                      * type-coercion functions.  Also, their join input
    2175             :                      * columns must be referenced in the join quals, so this
    2176             :                      * won't accidentally add refs to otherwise-unused join
    2177             :                      * input columns.  (We want to ref the type coercion
    2178             :                      * functions even if the merged column isn't explicitly
    2179             :                      * used anywhere, to protect possible expansion of the
    2180             :                      * join RTE as a whole-row var, and because it seems like
    2181             :                      * a bad idea to allow dropping a function that's present
    2182             :                      * in our query tree, whether or not it could get called.)
    2183             :                      */
    2184       13066 :                     context->rtables = lcons(query->rtable, context->rtables);
    2185       13266 :                     for (int i = 0; i < rte->joinmergedcols; i++)
    2186             :                     {
    2187         200 :                         Node       *aliasvar = list_nth(rte->joinaliasvars, i);
    2188             : 
    2189         200 :                         if (!IsA(aliasvar, Var))
    2190          48 :                             find_expr_references_walker(aliasvar, context);
    2191             :                     }
    2192       13066 :                     context->rtables = list_delete_first(context->rtables);
    2193       13066 :                     break;
    2194       13642 :                 default:
    2195       13642 :                     break;
    2196             :             }
    2197             :         }
    2198             : 
    2199             :         /*
    2200             :          * If the query is an INSERT or UPDATE, we should create a dependency
    2201             :          * on each target column, to prevent the specific target column from
    2202             :          * being dropped.  Although we will visit the TargetEntry nodes again
    2203             :          * during query_tree_walker, we won't have enough context to do this
    2204             :          * conveniently, so do it here.
    2205             :          */
    2206       33522 :         if (query->commandType == CMD_INSERT ||
    2207       33066 :             query->commandType == CMD_UPDATE)
    2208             :         {
    2209             :             RangeTblEntry *rte;
    2210             : 
    2211        1288 :             if (query->resultRelation <= 0 ||
    2212         644 :                 query->resultRelation > list_length(query->rtable))
    2213           0 :                 elog(ERROR, "invalid resultRelation %d",
    2214             :                      query->resultRelation);
    2215         644 :             rte = rt_fetch(query->resultRelation, query->rtable);
    2216         644 :             if (rte->rtekind == RTE_RELATION)
    2217             :             {
    2218        1986 :                 foreach(lc, query->targetList)
    2219             :                 {
    2220        1342 :                     TargetEntry *tle = (TargetEntry *) lfirst(lc);
    2221             : 
    2222        1342 :                     if (tle->resjunk)
    2223           6 :                         continue;   /* ignore junk tlist items */
    2224        1336 :                     add_object_address(RelationRelationId, rte->relid, tle->resno,
    2225             :                                        context->addrs);
    2226             :                 }
    2227             :             }
    2228             :         }
    2229             : 
    2230             :         /*
    2231             :          * Add dependencies on constraints listed in query's constraintDeps
    2232             :          */
    2233       33578 :         foreach(lc, query->constraintDeps)
    2234             :         {
    2235          56 :             add_object_address(ConstraintRelationId, lfirst_oid(lc), 0,
    2236             :                                context->addrs);
    2237             :         }
    2238             : 
    2239             :         /* Examine substructure of query */
    2240       33522 :         context->rtables = lcons(query->rtable, context->rtables);
    2241       33522 :         result = query_tree_walker(query,
    2242             :                                    find_expr_references_walker,
    2243             :                                    (void *) context,
    2244             :                                    QTW_IGNORE_JOINALIASES |
    2245             :                                    QTW_EXAMINE_SORTGROUP);
    2246       33522 :         context->rtables = list_delete_first(context->rtables);
    2247       33522 :         return result;
    2248             :     }
    2249      439686 :     else if (IsA(node, SetOperationStmt))
    2250             :     {
    2251        3462 :         SetOperationStmt *setop = (SetOperationStmt *) node;
    2252             : 
    2253             :         /* we need to look at the groupClauses for operator references */
    2254        3462 :         find_expr_references_walker((Node *) setop->groupClauses, context);
    2255             :         /* fall through to examine child nodes */
    2256             :     }
    2257      436224 :     else if (IsA(node, RangeTblFunction))
    2258             :     {
    2259        4400 :         RangeTblFunction *rtfunc = (RangeTblFunction *) node;
    2260             :         ListCell   *ct;
    2261             : 
    2262             :         /*
    2263             :          * Add refs for any datatypes and collations used in a column
    2264             :          * definition list for a RECORD function.  (For other cases, it should
    2265             :          * be enough to depend on the function itself.)
    2266             :          */
    2267        4508 :         foreach(ct, rtfunc->funccoltypes)
    2268             :         {
    2269         108 :             add_object_address(TypeRelationId, lfirst_oid(ct), 0,
    2270             :                                context->addrs);
    2271             :         }
    2272        4508 :         foreach(ct, rtfunc->funccolcollations)
    2273             :         {
    2274         108 :             Oid         collid = lfirst_oid(ct);
    2275             : 
    2276         108 :             if (OidIsValid(collid) && collid != DEFAULT_COLLATION_OID)
    2277           0 :                 add_object_address(CollationRelationId, collid, 0,
    2278             :                                    context->addrs);
    2279             :         }
    2280             :     }
    2281      431824 :     else if (IsA(node, TableFunc))
    2282             :     {
    2283          82 :         TableFunc  *tf = (TableFunc *) node;
    2284             :         ListCell   *ct;
    2285             : 
    2286             :         /*
    2287             :          * Add refs for the datatypes and collations used in the TableFunc.
    2288             :          */
    2289         388 :         foreach(ct, tf->coltypes)
    2290             :         {
    2291         306 :             add_object_address(TypeRelationId, lfirst_oid(ct), 0,
    2292             :                                context->addrs);
    2293             :         }
    2294         388 :         foreach(ct, tf->colcollations)
    2295             :         {
    2296         306 :             Oid         collid = lfirst_oid(ct);
    2297             : 
    2298         306 :             if (OidIsValid(collid) && collid != DEFAULT_COLLATION_OID)
    2299           0 :                 add_object_address(CollationRelationId, collid, 0,
    2300             :                                    context->addrs);
    2301             :         }
    2302             :     }
    2303      431742 :     else if (IsA(node, TableSampleClause))
    2304             :     {
    2305          20 :         TableSampleClause *tsc = (TableSampleClause *) node;
    2306             : 
    2307          20 :         add_object_address(ProcedureRelationId, tsc->tsmhandler, 0,
    2308             :                            context->addrs);
    2309             :         /* fall through to examine arguments */
    2310             :     }
    2311             : 
    2312      703756 :     return expression_tree_walker(node, find_expr_references_walker,
    2313             :                                   (void *) context);
    2314             : }
    2315             : 
    2316             : /*
    2317             :  * find_expr_references_walker subroutine: handle a Var reference
    2318             :  * to an RTE_FUNCTION RTE
    2319             :  */
    2320             : static void
    2321       37778 : process_function_rte_ref(RangeTblEntry *rte, AttrNumber attnum,
    2322             :                          find_expr_references_context *context)
    2323             : {
    2324       37778 :     int         atts_done = 0;
    2325             :     ListCell   *lc;
    2326             : 
    2327             :     /*
    2328             :      * Identify which RangeTblFunction produces this attnum, and see if it
    2329             :      * returns a composite type.  If so, we'd better make a dependency on the
    2330             :      * referenced column of the composite type (or actually, of its associated
    2331             :      * relation).
    2332             :      */
    2333       38000 :     foreach(lc, rte->functions)
    2334             :     {
    2335       37910 :         RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc);
    2336             : 
    2337       37910 :         if (attnum > atts_done &&
    2338       37910 :             attnum <= atts_done + rtfunc->funccolcount)
    2339             :         {
    2340             :             TupleDesc   tupdesc;
    2341             : 
    2342             :             /* If it has a coldeflist, it certainly returns RECORD */
    2343       37688 :             if (rtfunc->funccolnames != NIL)
    2344         108 :                 tupdesc = NULL; /* no need to work hard */
    2345             :             else
    2346       37580 :                 tupdesc = get_expr_result_tupdesc(rtfunc->funcexpr, true);
    2347       37688 :             if (tupdesc && tupdesc->tdtypeid != RECORDOID)
    2348             :             {
    2349             :                 /*
    2350             :                  * Named composite type, so individual columns could get
    2351             :                  * dropped.  Make a dependency on this specific column.
    2352             :                  */
    2353         222 :                 Oid         reltype = get_typ_typrelid(tupdesc->tdtypeid);
    2354             : 
    2355             :                 Assert(attnum - atts_done <= tupdesc->natts);
    2356         222 :                 if (OidIsValid(reltype))    /* can this fail? */
    2357         222 :                     add_object_address(RelationRelationId, reltype,
    2358             :                                        attnum - atts_done,
    2359             :                                        context->addrs);
    2360       37688 :                 return;
    2361             :             }
    2362             :             /* Nothing to do; function's result type is handled elsewhere */
    2363       37466 :             return;
    2364             :         }
    2365         222 :         atts_done += rtfunc->funccolcount;
    2366             :     }
    2367             : 
    2368             :     /* If we get here, must be looking for the ordinality column */
    2369          90 :     if (rte->funcordinality && attnum == atts_done + 1)
    2370          90 :         return;
    2371             : 
    2372             :     /* this probably can't happen ... */
    2373           0 :     ereport(ERROR,
    2374             :             (errcode(ERRCODE_UNDEFINED_COLUMN),
    2375             :              errmsg("column %d of relation \"%s\" does not exist",
    2376             :                     attnum, rte->eref->aliasname)));
    2377             : }
    2378             : 
    2379             : /*
    2380             :  * Given an array of dependency references, eliminate any duplicates.
    2381             :  */
    2382             : static void
    2383      346612 : eliminate_duplicate_dependencies(ObjectAddresses *addrs)
    2384             : {
    2385             :     ObjectAddress *priorobj;
    2386             :     int         oldref,
    2387             :                 newrefs;
    2388             : 
    2389             :     /*
    2390             :      * We can't sort if the array has "extra" data, because there's no way to
    2391             :      * keep it in sync.  Fortunately that combination of features is not
    2392             :      * needed.
    2393             :      */
    2394             :     Assert(!addrs->extras);
    2395             : 
    2396      346612 :     if (addrs->numrefs <= 1)
    2397       93010 :         return;                 /* nothing to do */
    2398             : 
    2399             :     /* Sort the refs so that duplicates are adjacent */
    2400      253602 :     qsort(addrs->refs, addrs->numrefs, sizeof(ObjectAddress),
    2401             :           object_address_comparator);
    2402             : 
    2403             :     /* Remove dups */
    2404      253602 :     priorobj = addrs->refs;
    2405      253602 :     newrefs = 1;
    2406     1708640 :     for (oldref = 1; oldref < addrs->numrefs; oldref++)
    2407             :     {
    2408     1455038 :         ObjectAddress *thisobj = addrs->refs + oldref;
    2409             : 
    2410     1455038 :         if (priorobj->classId == thisobj->classId &&
    2411     1249262 :             priorobj->objectId == thisobj->objectId)
    2412             :         {
    2413      669354 :             if (priorobj->objectSubId == thisobj->objectSubId)
    2414      515440 :                 continue;       /* identical, so drop thisobj */
    2415             : 
    2416             :             /*
    2417             :              * If we have a whole-object reference and a reference to a part
    2418             :              * of the same object, we don't need the whole-object reference
    2419             :              * (for example, we don't need to reference both table foo and
    2420             :              * column foo.bar).  The whole-object reference will always appear
    2421             :              * first in the sorted list.
    2422             :              */
    2423      153914 :             if (priorobj->objectSubId == 0)
    2424             :             {
    2425             :                 /* replace whole ref with partial */
    2426       33512 :                 priorobj->objectSubId = thisobj->objectSubId;
    2427       33512 :                 continue;
    2428             :             }
    2429             :         }
    2430             :         /* Not identical, so add thisobj to output set */
    2431      906086 :         priorobj++;
    2432      906086 :         *priorobj = *thisobj;
    2433      906086 :         newrefs++;
    2434             :     }
    2435             : 
    2436      253602 :     addrs->numrefs = newrefs;
    2437             : }
    2438             : 
    2439             : /*
    2440             :  * qsort comparator for ObjectAddress items
    2441             :  */
    2442             : static int
    2443     4980870 : object_address_comparator(const void *a, const void *b)
    2444             : {
    2445     4980870 :     const ObjectAddress *obja = (const ObjectAddress *) a;
    2446     4980870 :     const ObjectAddress *objb = (const ObjectAddress *) b;
    2447             : 
    2448             :     /*
    2449             :      * Primary sort key is OID descending.  Most of the time, this will result
    2450             :      * in putting newer objects before older ones, which is likely to be the
    2451             :      * right order to delete in.
    2452             :      */
    2453     4980870 :     if (obja->objectId > objb->objectId)
    2454     1181024 :         return -1;
    2455     3799846 :     if (obja->objectId < objb->objectId)
    2456     2638612 :         return 1;
    2457             : 
    2458             :     /*
    2459             :      * Next sort on catalog ID, in case identical OIDs appear in different
    2460             :      * catalogs.  Sort direction is pretty arbitrary here.
    2461             :      */
    2462     1161234 :     if (obja->classId < objb->classId)
    2463           0 :         return -1;
    2464     1161234 :     if (obja->classId > objb->classId)
    2465           0 :         return 1;
    2466             : 
    2467             :     /*
    2468             :      * Last, sort on object subId.
    2469             :      *
    2470             :      * We sort the subId as an unsigned int so that 0 (the whole object) will
    2471             :      * come first.  This is essential for eliminate_duplicate_dependencies,
    2472             :      * and is also the best order for findDependentObjects.
    2473             :      */
    2474     1161234 :     if ((unsigned int) obja->objectSubId < (unsigned int) objb->objectSubId)
    2475      281518 :         return -1;
    2476      879716 :     if ((unsigned int) obja->objectSubId > (unsigned int) objb->objectSubId)
    2477      247586 :         return 1;
    2478      632130 :     return 0;
    2479             : }
    2480             : 
    2481             : /*
    2482             :  * Routines for handling an expansible array of ObjectAddress items.
    2483             :  *
    2484             :  * new_object_addresses: create a new ObjectAddresses array.
    2485             :  */
    2486             : ObjectAddresses *
    2487      406124 : new_object_addresses(void)
    2488             : {
    2489             :     ObjectAddresses *addrs;
    2490             : 
    2491      406124 :     addrs = palloc(sizeof(ObjectAddresses));
    2492             : 
    2493      406124 :     addrs->numrefs = 0;
    2494      406124 :     addrs->maxrefs = 32;
    2495      406124 :     addrs->refs = (ObjectAddress *)
    2496      406124 :         palloc(addrs->maxrefs * sizeof(ObjectAddress));
    2497      406124 :     addrs->extras = NULL;        /* until/unless needed */
    2498             : 
    2499      406124 :     return addrs;
    2500             : }
    2501             : 
    2502             : /*
    2503             :  * Add an entry to an ObjectAddresses array.
    2504             :  */
    2505             : static void
    2506      711200 : add_object_address(Oid classId, Oid objectId, int32 subId,
    2507             :                    ObjectAddresses *addrs)
    2508             : {
    2509             :     ObjectAddress *item;
    2510             : 
    2511             :     /* enlarge array if needed */
    2512      711200 :     if (addrs->numrefs >= addrs->maxrefs)
    2513             :     {
    2514        9494 :         addrs->maxrefs *= 2;
    2515        9494 :         addrs->refs = (ObjectAddress *)
    2516        9494 :             repalloc(addrs->refs, addrs->maxrefs * sizeof(ObjectAddress));
    2517             :         Assert(!addrs->extras);
    2518             :     }
    2519             :     /* record this item */
    2520      711200 :     item = addrs->refs + addrs->numrefs;
    2521      711200 :     item->classId = classId;
    2522      711200 :     item->objectId = objectId;
    2523      711200 :     item->objectSubId = subId;
    2524      711200 :     addrs->numrefs++;
    2525      711200 : }
    2526             : 
    2527             : /*
    2528             :  * Add an entry to an ObjectAddresses array.
    2529             :  *
    2530             :  * As above, but specify entry exactly.
    2531             :  */
    2532             : void
    2533     1100334 : add_exact_object_address(const ObjectAddress *object,
    2534             :                          ObjectAddresses *addrs)
    2535             : {
    2536             :     ObjectAddress *item;
    2537             : 
    2538             :     /* enlarge array if needed */
    2539     1100334 :     if (addrs->numrefs >= addrs->maxrefs)
    2540             :     {
    2541          52 :         addrs->maxrefs *= 2;
    2542          52 :         addrs->refs = (ObjectAddress *)
    2543          52 :             repalloc(addrs->refs, addrs->maxrefs * sizeof(ObjectAddress));
    2544             :         Assert(!addrs->extras);
    2545             :     }
    2546             :     /* record this item */
    2547     1100334 :     item = addrs->refs + addrs->numrefs;
    2548     1100334 :     *item = *object;
    2549     1100334 :     addrs->numrefs++;
    2550     1100334 : }
    2551             : 
    2552             : /*
    2553             :  * Add an entry to an ObjectAddresses array.
    2554             :  *
    2555             :  * As above, but specify entry exactly and provide some "extra" data too.
    2556             :  */
    2557             : static void
    2558      180008 : add_exact_object_address_extra(const ObjectAddress *object,
    2559             :                                const ObjectAddressExtra *extra,
    2560             :                                ObjectAddresses *addrs)
    2561             : {
    2562             :     ObjectAddress *item;
    2563             :     ObjectAddressExtra *itemextra;
    2564             : 
    2565             :     /* allocate extra space if first time */
    2566      180008 :     if (!addrs->extras)
    2567       29814 :         addrs->extras = (ObjectAddressExtra *)
    2568       29814 :             palloc(addrs->maxrefs * sizeof(ObjectAddressExtra));
    2569             : 
    2570             :     /* enlarge array if needed */
    2571      180008 :     if (addrs->numrefs >= addrs->maxrefs)
    2572             :     {
    2573         634 :         addrs->maxrefs *= 2;
    2574         634 :         addrs->refs = (ObjectAddress *)
    2575         634 :             repalloc(addrs->refs, addrs->maxrefs * sizeof(ObjectAddress));
    2576         634 :         addrs->extras = (ObjectAddressExtra *)
    2577         634 :             repalloc(addrs->extras, addrs->maxrefs * sizeof(ObjectAddressExtra));
    2578             :     }
    2579             :     /* record this item */
    2580      180008 :     item = addrs->refs + addrs->numrefs;
    2581      180008 :     *item = *object;
    2582      180008 :     itemextra = addrs->extras + addrs->numrefs;
    2583      180008 :     *itemextra = *extra;
    2584      180008 :     addrs->numrefs++;
    2585      180008 : }
    2586             : 
    2587             : /*
    2588             :  * Test whether an object is present in an ObjectAddresses array.
    2589             :  *
    2590             :  * We return "true" if object is a subobject of something in the array, too.
    2591             :  */
    2592             : bool
    2593         576 : object_address_present(const ObjectAddress *object,
    2594             :                        const ObjectAddresses *addrs)
    2595             : {
    2596             :     int         i;
    2597             : 
    2598        1968 :     for (i = addrs->numrefs - 1; i >= 0; i--)
    2599             :     {
    2600        1392 :         const ObjectAddress *thisobj = addrs->refs + i;
    2601             : 
    2602        1392 :         if (object->classId == thisobj->classId &&
    2603         394 :             object->objectId == thisobj->objectId)
    2604             :         {
    2605           0 :             if (object->objectSubId == thisobj->objectSubId ||
    2606           0 :                 thisobj->objectSubId == 0)
    2607           0 :                 return true;
    2608             :         }
    2609             :     }
    2610             : 
    2611         576 :     return false;
    2612             : }
    2613             : 
    2614             : /*
    2615             :  * As above, except that if the object is present then also OR the given
    2616             :  * flags into its associated extra data (which must exist).
    2617             :  */
    2618             : static bool
    2619      224400 : object_address_present_add_flags(const ObjectAddress *object,
    2620             :                                  int flags,
    2621             :                                  ObjectAddresses *addrs)
    2622             : {
    2623      224400 :     bool        result = false;
    2624             :     int         i;
    2625             : 
    2626     5423074 :     for (i = addrs->numrefs - 1; i >= 0; i--)
    2627             :     {
    2628     5198674 :         ObjectAddress *thisobj = addrs->refs + i;
    2629             : 
    2630     5198674 :         if (object->classId == thisobj->classId &&
    2631     1719030 :             object->objectId == thisobj->objectId)
    2632             :         {
    2633       42848 :             if (object->objectSubId == thisobj->objectSubId)
    2634             :             {
    2635       42416 :                 ObjectAddressExtra *thisextra = addrs->extras + i;
    2636             : 
    2637       42416 :                 thisextra->flags |= flags;
    2638       42416 :                 result = true;
    2639             :             }
    2640         432 :             else if (thisobj->objectSubId == 0)
    2641             :             {
    2642             :                 /*
    2643             :                  * We get here if we find a need to delete a column after
    2644             :                  * having already decided to drop its whole table.  Obviously
    2645             :                  * we no longer need to drop the subobject, so report that we
    2646             :                  * found the subobject in the array.  But don't plaster its
    2647             :                  * flags on the whole object.
    2648             :                  */
    2649         414 :                 result = true;
    2650             :             }
    2651          18 :             else if (object->objectSubId == 0)
    2652             :             {
    2653             :                 /*
    2654             :                  * We get here if we find a need to delete a whole table after
    2655             :                  * having already decided to drop one of its columns.  We
    2656             :                  * can't report that the whole object is in the array, but we
    2657             :                  * should mark the subobject with the whole object's flags.
    2658             :                  *
    2659             :                  * It might seem attractive to physically delete the column's
    2660             :                  * array entry, or at least mark it as no longer needing
    2661             :                  * separate deletion.  But that could lead to, e.g., dropping
    2662             :                  * the column's datatype before we drop the table, which does
    2663             :                  * not seem like a good idea.  This is a very rare situation
    2664             :                  * in practice, so we just take the hit of doing a separate
    2665             :                  * DROP COLUMN action even though we know we're gonna delete
    2666             :                  * the table later.
    2667             :                  *
    2668             :                  * What we can do, though, is mark this as a subobject so that
    2669             :                  * we don't report it separately, which is confusing because
    2670             :                  * it's unpredictable whether it happens or not.  But do so
    2671             :                  * only if flags != 0 (flags == 0 is a read-only probe).
    2672             :                  *
    2673             :                  * Because there could be other subobjects of this object in
    2674             :                  * the array, this case means we always have to loop through
    2675             :                  * the whole array; we cannot exit early on a match.
    2676             :                  */
    2677           6 :                 ObjectAddressExtra *thisextra = addrs->extras + i;
    2678             : 
    2679           6 :                 if (flags)
    2680           6 :                     thisextra->flags |= (flags | DEPFLAG_SUBOBJECT);
    2681             :             }
    2682             :         }
    2683             :     }
    2684             : 
    2685      224400 :     return result;
    2686             : }
    2687             : 
    2688             : /*
    2689             :  * Similar to above, except we search an ObjectAddressStack.
    2690             :  */
    2691             : static bool
    2692      325386 : stack_address_present_add_flags(const ObjectAddress *object,
    2693             :                                 int flags,
    2694             :                                 ObjectAddressStack *stack)
    2695             : {
    2696      325386 :     bool        result = false;
    2697             :     ObjectAddressStack *stackptr;
    2698             : 
    2699      870166 :     for (stackptr = stack; stackptr; stackptr = stackptr->next)
    2700             :     {
    2701      544780 :         const ObjectAddress *thisobj = stackptr->object;
    2702             : 
    2703      544780 :         if (object->classId == thisobj->classId &&
    2704      251424 :             object->objectId == thisobj->objectId)
    2705             :         {
    2706      101022 :             if (object->objectSubId == thisobj->objectSubId)
    2707             :             {
    2708      100376 :                 stackptr->flags |= flags;
    2709      100376 :                 result = true;
    2710             :             }
    2711         646 :             else if (thisobj->objectSubId == 0)
    2712             :             {
    2713             :                 /*
    2714             :                  * We're visiting a column with whole table already on stack.
    2715             :                  * As in object_address_present_add_flags(), we can skip
    2716             :                  * further processing of the subobject, but we don't want to
    2717             :                  * propagate flags for the subobject to the whole object.
    2718             :                  */
    2719         610 :                 result = true;
    2720             :             }
    2721          36 :             else if (object->objectSubId == 0)
    2722             :             {
    2723             :                 /*
    2724             :                  * We're visiting a table with column already on stack.  As in
    2725             :                  * object_address_present_add_flags(), we should propagate
    2726             :                  * flags for the whole object to each of its subobjects.
    2727             :                  */
    2728           0 :                 if (flags)
    2729           0 :                     stackptr->flags |= (flags | DEPFLAG_SUBOBJECT);
    2730             :             }
    2731             :         }
    2732             :     }
    2733             : 
    2734      325386 :     return result;
    2735             : }
    2736             : 
    2737             : /*
    2738             :  * Record multiple dependencies from an ObjectAddresses array, after first
    2739             :  * removing any duplicates.
    2740             :  */
    2741             : void
    2742      311380 : record_object_address_dependencies(const ObjectAddress *depender,
    2743             :                                    ObjectAddresses *referenced,
    2744             :                                    DependencyType behavior)
    2745             : {
    2746      311380 :     eliminate_duplicate_dependencies(referenced);
    2747      311380 :     recordMultipleDependencies(depender,
    2748      311380 :                                referenced->refs, referenced->numrefs,
    2749             :                                behavior);
    2750      311380 : }
    2751             : 
    2752             : /*
    2753             :  * Sort the items in an ObjectAddresses array.
    2754             :  *
    2755             :  * The major sort key is OID-descending, so that newer objects will be listed
    2756             :  * first in most cases.  This is primarily useful for ensuring stable outputs
    2757             :  * from regression tests; it's not recommended if the order of the objects is
    2758             :  * determined by user input, such as the order of targets in a DROP command.
    2759             :  */
    2760             : void
    2761         136 : sort_object_addresses(ObjectAddresses *addrs)
    2762             : {
    2763         136 :     if (addrs->numrefs > 1)
    2764          76 :         qsort(addrs->refs, addrs->numrefs,
    2765             :               sizeof(ObjectAddress),
    2766             :               object_address_comparator);
    2767         136 : }
    2768             : 
    2769             : /*
    2770             :  * Clean up when done with an ObjectAddresses array.
    2771             :  */
    2772             : void
    2773      404124 : free_object_addresses(ObjectAddresses *addrs)
    2774             : {
    2775      404124 :     pfree(addrs->refs);
    2776      404124 :     if (addrs->extras)
    2777       29478 :         pfree(addrs->extras);
    2778      404124 :     pfree(addrs);
    2779      404124 : }
    2780             : 
    2781             : /*
    2782             :  * delete initial ACL for extension objects
    2783             :  */
    2784             : static void
    2785      175174 : DeleteInitPrivs(const ObjectAddress *object)
    2786             : {
    2787             :     Relation    relation;
    2788             :     ScanKeyData key[3];
    2789             :     int         nkeys;
    2790             :     SysScanDesc scan;
    2791             :     HeapTuple   oldtuple;
    2792             : 
    2793      175174 :     relation = table_open(InitPrivsRelationId, RowExclusiveLock);
    2794             : 
    2795      175174 :     ScanKeyInit(&key[0],
    2796             :                 Anum_pg_init_privs_objoid,
    2797             :                 BTEqualStrategyNumber, F_OIDEQ,
    2798             :                 ObjectIdGetDatum(object->objectId));
    2799      175174 :     ScanKeyInit(&key[1],
    2800             :                 Anum_pg_init_privs_classoid,
    2801             :                 BTEqualStrategyNumber, F_OIDEQ,
    2802             :                 ObjectIdGetDatum(object->classId));
    2803      175174 :     if (object->objectSubId != 0)
    2804             :     {
    2805        1990 :         ScanKeyInit(&key[2],
    2806             :                     Anum_pg_init_privs_objsubid,
    2807             :                     BTEqualStrategyNumber, F_INT4EQ,
    2808             :                     Int32GetDatum(object->objectSubId));
    2809        1990 :         nkeys = 3;
    2810             :     }
    2811             :     else
    2812      173184 :         nkeys = 2;
    2813             : 
    2814      175174 :     scan = systable_beginscan(relation, InitPrivsObjIndexId, true,
    2815             :                               NULL, nkeys, key);
    2816             : 
    2817      175292 :     while (HeapTupleIsValid(oldtuple = systable_getnext(scan)))
    2818         118 :         CatalogTupleDelete(relation, &oldtuple->t_self);
    2819             : 
    2820      175174 :     systable_endscan(scan);
    2821             : 
    2822      175174 :     table_close(relation, RowExclusiveLock);
    2823      175174 : }

Generated by: LCOV version 1.14