LCOV - code coverage report
Current view: top level - src/backend/catalog - dependency.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 750 834 89.9 %
Date: 2024-05-19 07:11: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       29010 : 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       29010 :     if (trackDroppedObjectsNeeded() && !(flags & PERFORM_DELETION_INTERNAL))
     194             :     {
     195        4016 :         for (i = 0; i < targetObjects->numrefs; i++)
     196             :         {
     197        3358 :             const ObjectAddress *thisobj = &targetObjects->refs[i];
     198        3358 :             const ObjectAddressExtra *extra = &targetObjects->extras[i];
     199        3358 :             bool        original = false;
     200        3358 :             bool        normal = false;
     201             : 
     202        3358 :             if (extra->flags & DEPFLAG_ORIGINAL)
     203         742 :                 original = true;
     204        3358 :             if (extra->flags & DEPFLAG_NORMAL)
     205         330 :                 normal = true;
     206        3358 :             if (extra->flags & DEPFLAG_REVERSE)
     207           0 :                 normal = true;
     208             : 
     209        3358 :             if (EventTriggerSupportsObject(thisobj))
     210             :             {
     211        3246 :                 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      203368 :     for (i = 0; i < targetObjects->numrefs; i++)
     221             :     {
     222      174362 :         ObjectAddress *thisobj = targetObjects->refs + i;
     223      174362 :         ObjectAddressExtra *thisextra = targetObjects->extras + i;
     224             : 
     225      174362 :         if ((flags & PERFORM_DELETION_SKIP_ORIGINAL) &&
     226        8584 :             (thisextra->flags & DEPFLAG_ORIGINAL))
     227         810 :             continue;
     228             : 
     229      173552 :         deleteOneObject(thisobj, depRel, flags);
     230             :     }
     231       29006 : }
     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        4730 : 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        4730 :     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        4730 :     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        4730 :     targetObjects = new_object_addresses();
     296             : 
     297        4730 :     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        4730 :     reportDependentObjects(targetObjects,
     309             :                            behavior,
     310             :                            flags,
     311             :                            object);
     312             : 
     313             :     /* do the deed */
     314        4694 :     deleteObjectsInList(targetObjects, &depRel, flags);
     315             : 
     316             :     /* And clean up */
     317        4692 :     free_object_addresses(targetObjects);
     318             : 
     319        4692 :     table_close(depRel, RowExclusiveLock);
     320        4692 : }
     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       27134 : 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       27134 :     if (objects->numrefs <= 0)
     341        2486 :         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       24648 :     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       24648 :     targetObjects = new_object_addresses();
     358             : 
     359       53978 :     for (i = 0; i < objects->numrefs; i++)
     360             :     {
     361       29372 :         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       29372 :         AcquireDeletionLock(thisobj, flags);
     368             : 
     369       29372 :         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       24606 :     reportDependentObjects(targetObjects,
     385             :                            behavior,
     386             :                            flags,
     387       24606 :                            (objects->numrefs == 1 ? objects->refs : NULL));
     388             : 
     389             :     /* do the deed */
     390       24316 :     deleteObjectsInList(targetObjects, &depRel, flags);
     391             : 
     392             :     /* And clean up */
     393       24314 :     free_object_addresses(targetObjects);
     394             : 
     395       24314 :     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      220610 : 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      220610 :     if (stack_address_present_add_flags(object, objflags, stack))
     470       42218 :         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      220340 :     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      220340 :     if (object_address_present_add_flags(object, objflags, targetObjects))
     488       40506 :         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      179834 :     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      179832 :     ScanKeyInit(&key[0],
     511             :                 Anum_pg_depend_classid,
     512             :                 BTEqualStrategyNumber, F_OIDEQ,
     513             :                 ObjectIdGetDatum(object->classId));
     514      179832 :     ScanKeyInit(&key[1],
     515             :                 Anum_pg_depend_objid,
     516             :                 BTEqualStrategyNumber, F_OIDEQ,
     517             :                 ObjectIdGetDatum(object->objectId));
     518      179832 :     if (object->objectSubId != 0)
     519             :     {
     520             :         /* Consider only dependencies of this sub-object */
     521        2092 :         ScanKeyInit(&key[2],
     522             :                     Anum_pg_depend_objsubid,
     523             :                     BTEqualStrategyNumber, F_INT4EQ,
     524             :                     Int32GetDatum(object->objectSubId));
     525        2092 :         nkeys = 3;
     526             :     }
     527             :     else
     528             :     {
     529             :         /* Consider dependencies of this object and any sub-objects it has */
     530      177740 :         nkeys = 2;
     531             :     }
     532             : 
     533      179832 :     scan = systable_beginscan(*depRel, DependDependerIndexId, true,
     534             :                               NULL, nkeys, key);
     535             : 
     536             :     /* initialize variables that loop may fill */
     537      179832 :     memset(&owningObject, 0, sizeof(owningObject));
     538      179832 :     memset(&partitionObject, 0, sizeof(partitionObject));
     539             : 
     540      432738 :     while (HeapTupleIsValid(tup = systable_getnext(scan)))
     541             :     {
     542      254348 :         Form_pg_depend foundDep = (Form_pg_depend) GETSTRUCT(tup);
     543             : 
     544      254348 :         otherObject.classId = foundDep->refclassid;
     545      254348 :         otherObject.objectId = foundDep->refobjid;
     546      254348 :         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      254348 :         if (otherObject.classId == object->classId &&
     556       92026 :             otherObject.objectId == object->objectId &&
     557        4304 :             object->objectSubId == 0)
     558        4280 :             continue;
     559             : 
     560      250068 :         switch (foundDep->deptype)
     561             :         {
     562      139504 :             case DEPENDENCY_NORMAL:
     563             :             case DEPENDENCY_AUTO:
     564             :             case DEPENDENCY_AUTO_EXTENSION:
     565             :                 /* no problem */
     566      139504 :                 break;
     567             : 
     568        3144 :             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        3144 :                 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        3136 :                 if (creating_extension &&
     588         286 :                     otherObject.classId == ExtensionRelationId &&
     589         286 :                     otherObject.objectId == CurrentExtensionObject)
     590         286 :                     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      100570 :                 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      100530 :                 if (stack_address_present_add_flags(&otherObject, 0, stack))
     650       99088 :                     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        1442 :                 ReleaseDeletionLock(object);
     663        1442 :                 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        1442 :                 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        1442 :                 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        1442 :                 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        1442 :                 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        1442 :                 return;
     728             : 
     729        4850 :             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        4850 :                 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        4850 :                 partitionObject = otherObject;
     744        4850 :                 break;
     745             : 
     746        4850 :             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        4850 :                 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        4850 :                 objflags |= DEPFLAG_IS_PART;
     761        4850 :                 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      178390 :     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      178390 :     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      178350 :     maxDependentObjects = 128;  /* arbitrary initial allocation */
     803             :     dependentObjects = (ObjectAddressAndFlags *)
     804      178350 :         palloc(maxDependentObjects * sizeof(ObjectAddressAndFlags));
     805      178350 :     numDependentObjects = 0;
     806             : 
     807      178350 :     ScanKeyInit(&key[0],
     808             :                 Anum_pg_depend_refclassid,
     809             :                 BTEqualStrategyNumber, F_OIDEQ,
     810             :                 ObjectIdGetDatum(object->classId));
     811      178350 :     ScanKeyInit(&key[1],
     812             :                 Anum_pg_depend_refobjid,
     813             :                 BTEqualStrategyNumber, F_OIDEQ,
     814             :                 ObjectIdGetDatum(object->objectId));
     815      178350 :     if (object->objectSubId != 0)
     816             :     {
     817        2068 :         ScanKeyInit(&key[2],
     818             :                     Anum_pg_depend_refobjsubid,
     819             :                     BTEqualStrategyNumber, F_INT4EQ,
     820             :                     Int32GetDatum(object->objectSubId));
     821        2068 :         nkeys = 3;
     822             :     }
     823             :     else
     824      176282 :         nkeys = 2;
     825             : 
     826      178350 :     scan = systable_beginscan(*depRel, DependReferenceIndexId, true,
     827             :                               NULL, nkeys, key);
     828             : 
     829      367696 :     while (HeapTupleIsValid(tup = systable_getnext(scan)))
     830             :     {
     831      189346 :         Form_pg_depend foundDep = (Form_pg_depend) GETSTRUCT(tup);
     832             :         int         subflags;
     833             : 
     834      189346 :         otherObject.classId = foundDep->classid;
     835      189346 :         otherObject.objectId = foundDep->objid;
     836      189346 :         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      189346 :         if (otherObject.classId == object->classId &&
     844       88042 :             otherObject.objectId == object->objectId &&
     845        4280 :             object->objectSubId == 0)
     846        4280 :             continue;
     847             : 
     848             :         /*
     849             :          * Must lock the dependent object before recursing to it.
     850             :          */
     851      185066 :         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      185066 :         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      185066 :         switch (foundDep->deptype)
     873             :         {
     874       25038 :             case DEPENDENCY_NORMAL:
     875       25038 :                 subflags = DEPFLAG_NORMAL;
     876       25038 :                 break;
     877       52062 :             case DEPENDENCY_AUTO:
     878             :             case DEPENDENCY_AUTO_EXTENSION:
     879       52062 :                 subflags = DEPFLAG_AUTO;
     880       52062 :                 break;
     881       96248 :             case DEPENDENCY_INTERNAL:
     882       96248 :                 subflags = DEPFLAG_INTERNAL;
     883       96248 :                 break;
     884        8924 :             case DEPENDENCY_PARTITION_PRI:
     885             :             case DEPENDENCY_PARTITION_SEC:
     886        8924 :                 subflags = DEPFLAG_PARTITION;
     887        8924 :                 break;
     888        2794 :             case DEPENDENCY_EXTENSION:
     889        2794 :                 subflags = DEPFLAG_EXTENSION;
     890        2794 :                 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      185066 :         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      185066 :         dependentObjects[numDependentObjects].obj = otherObject;
     909      185066 :         dependentObjects[numDependentObjects].subflags = subflags;
     910      185066 :         numDependentObjects++;
     911             :     }
     912             : 
     913      178350 :     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      178350 :     if (numDependentObjects > 1)
     921       40228 :         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      178350 :     mystack.object = object;    /* set up a new stack level */
     930      178350 :     mystack.flags = objflags;
     931      178350 :     mystack.next = stack;
     932             : 
     933      363416 :     for (int i = 0; i < numDependentObjects; i++)
     934             :     {
     935      185066 :         ObjectAddressAndFlags *depObj = dependentObjects + i;
     936             : 
     937      185066 :         findDependentObjects(&depObj->obj,
     938             :                              depObj->subflags,
     939             :                              flags,
     940             :                              &mystack,
     941             :                              targetObjects,
     942             :                              pendingObjects,
     943             :                              depRel);
     944             :     }
     945             : 
     946      178350 :     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      178350 :     extra.flags = mystack.flags;
     957      178350 :     if (extra.flags & DEPFLAG_IS_PART)
     958        4838 :         extra.dependee = partitionObject;
     959      173512 :     else if (stack)
     960      139864 :         extra.dependee = *stack->object;
     961             :     else
     962       33648 :         memset(&extra.dependee, 0, sizeof(extra.dependee));
     963      178350 :     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       29336 : reportDependentObjects(const ObjectAddresses *targetObjects,
     981             :                        DropBehavior behavior,
     982             :                        int flags,
     983             :                        const ObjectAddress *origObject)
     984             : {
     985       29336 :     int         msglevel = (flags & PERFORM_DELETION_QUIETLY) ? DEBUG2 : NOTICE;
     986       29336 :     bool        ok = true;
     987             :     StringInfoData clientdetail;
     988             :     StringInfoData logdetail;
     989       29336 :     int         numReportedClient = 0;
     990       29336 :     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      207656 :     for (i = 0; i < targetObjects->numrefs; i++)
    1004             :     {
    1005      178350 :         const ObjectAddressExtra *extra = &targetObjects->extras[i];
    1006             : 
    1007      178350 :         if ((extra->flags & DEPFLAG_IS_PART) &&
    1008        4838 :             !(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       29306 :     if (behavior == DROP_CASCADE &&
    1028        3194 :         !message_level_is_interesting(msglevel))
    1029         874 :         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       28432 :     initStringInfo(&clientdetail);
    1039       28432 :     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      195818 :     for (i = targetObjects->numrefs - 1; i >= 0; i--)
    1046             :     {
    1047      167386 :         const ObjectAddress *obj = &targetObjects->refs[i];
    1048      167386 :         const ObjectAddressExtra *extra = &targetObjects->extras[i];
    1049             :         char       *objDesc;
    1050             : 
    1051             :         /* Ignore the original deletion target(s) */
    1052      167386 :         if (extra->flags & DEPFLAG_ORIGINAL)
    1053       33144 :             continue;
    1054             : 
    1055             :         /* Also ignore sub-objects; we'll report the whole object elsewhere */
    1056      134242 :         if (extra->flags & DEPFLAG_SUBOBJECT)
    1057           0 :             continue;
    1058             : 
    1059      134242 :         objDesc = getObjectDescription(obj, false);
    1060             : 
    1061             :         /* An object being dropped concurrently doesn't need to be reported */
    1062      134242 :         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      134242 :         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      129572 :             ereport(DEBUG2,
    1082             :                     (errmsg_internal("drop auto-cascades to %s",
    1083             :                                      objDesc)));
    1084             :         }
    1085        4670 :         else if (behavior == DROP_RESTRICT)
    1086             :         {
    1087         502 :             char       *otherDesc = getObjectDescription(&extra->dependee,
    1088             :                                                          false);
    1089             : 
    1090         502 :             if (otherDesc)
    1091             :             {
    1092         502 :                 if (numReportedClient < MAX_REPORTED_DEPS)
    1093             :                 {
    1094             :                     /* separate entries with a newline */
    1095         502 :                     if (clientdetail.len != 0)
    1096         206 :                         appendStringInfoChar(&clientdetail, '\n');
    1097         502 :                     appendStringInfo(&clientdetail, _("%s depends on %s"),
    1098             :                                      objDesc, otherDesc);
    1099         502 :                     numReportedClient++;
    1100             :                 }
    1101             :                 else
    1102           0 :                     numNotReportedClient++;
    1103             :                 /* separate entries with a newline */
    1104         502 :                 if (logdetail.len != 0)
    1105         206 :                     appendStringInfoChar(&logdetail, '\n');
    1106         502 :                 appendStringInfo(&logdetail, _("%s depends on %s"),
    1107             :                                  objDesc, otherDesc);
    1108         502 :                 pfree(otherDesc);
    1109             :             }
    1110             :             else
    1111           0 :                 numNotReportedClient++;
    1112         502 :             ok = false;
    1113             :         }
    1114             :         else
    1115             :         {
    1116        4168 :             if (numReportedClient < MAX_REPORTED_DEPS)
    1117             :             {
    1118             :                 /* separate entries with a newline */
    1119        4168 :                 if (clientdetail.len != 0)
    1120        2856 :                     appendStringInfoChar(&clientdetail, '\n');
    1121        4168 :                 appendStringInfo(&clientdetail, _("drop cascades to %s"),
    1122             :                                  objDesc);
    1123        4168 :                 numReportedClient++;
    1124             :             }
    1125             :             else
    1126           0 :                 numNotReportedClient++;
    1127             :             /* separate entries with a newline */
    1128        4168 :             if (logdetail.len != 0)
    1129        2856 :                 appendStringInfoChar(&logdetail, '\n');
    1130        4168 :             appendStringInfo(&logdetail, _("drop cascades to %s"),
    1131             :                              objDesc);
    1132             :         }
    1133             : 
    1134      134242 :         pfree(objDesc);
    1135             :     }
    1136             : 
    1137       28432 :     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       28432 :     if (!ok)
    1146             :     {
    1147         296 :         if (origObject)
    1148         290 :             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       28136 :     else if (numReportedClient > 1)
    1164             :     {
    1165         624 :         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       27512 :     else if (numReportedClient == 1)
    1174             :     {
    1175             :         /* we just use the single item as-is */
    1176         688 :         ereport(msglevel,
    1177             :                 (errmsg_internal("%s", clientdetail.data)));
    1178             :     }
    1179             : 
    1180       28136 :     pfree(clientdetail.data);
    1181       28136 :     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        3216 : DropObjectById(const ObjectAddress *object)
    1190             : {
    1191             :     int         cacheId;
    1192             :     Relation    rel;
    1193             :     HeapTuple   tup;
    1194             : 
    1195        3216 :     cacheId = get_object_catcache_oid(object->classId);
    1196             : 
    1197        3216 :     rel = table_open(object->classId, RowExclusiveLock);
    1198             : 
    1199             :     /*
    1200             :      * Use the system cache for the oid column, if one exists.
    1201             :      */
    1202        3216 :     if (cacheId >= 0)
    1203             :     {
    1204        1754 :         tup = SearchSysCache1(cacheId, ObjectIdGetDatum(object->objectId));
    1205        1754 :         if (!HeapTupleIsValid(tup))
    1206           0 :             elog(ERROR, "cache lookup failed for %s %u",
    1207             :                  get_object_class_descr(object->classId), object->objectId);
    1208             : 
    1209        1754 :         CatalogTupleDelete(rel, &tup->t_self);
    1210             : 
    1211        1754 :         ReleaseSysCache(tup);
    1212             :     }
    1213             :     else
    1214             :     {
    1215             :         ScanKeyData skey[1];
    1216             :         SysScanDesc scan;
    1217             : 
    1218        2924 :         ScanKeyInit(&skey[0],
    1219        1462 :                     get_object_attnum_oid(object->classId),
    1220             :                     BTEqualStrategyNumber, F_OIDEQ,
    1221             :                     ObjectIdGetDatum(object->objectId));
    1222             : 
    1223        1462 :         scan = systable_beginscan(rel, get_object_oid_index(object->classId), true,
    1224             :                                   NULL, 1, skey);
    1225             : 
    1226             :         /* we expect exactly one match */
    1227        1462 :         tup = systable_getnext(scan);
    1228        1462 :         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        1462 :         CatalogTupleDelete(rel, &tup->t_self);
    1233             : 
    1234        1462 :         systable_endscan(scan);
    1235             :     }
    1236             : 
    1237        3216 :     table_close(rel, RowExclusiveLock);
    1238        3216 : }
    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      173552 : 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      173552 :     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      173552 :     if (flags & PERFORM_DELETION_CONCURRENTLY)
    1263          80 :         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      173552 :     doDeletion(object, flags);
    1275             : 
    1276             :     /*
    1277             :      * Reopen depRel if we closed it above
    1278             :      */
    1279      173548 :     if (flags & PERFORM_DELETION_CONCURRENTLY)
    1280          80 :         *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      173548 :     ScanKeyInit(&key[0],
    1290             :                 Anum_pg_depend_classid,
    1291             :                 BTEqualStrategyNumber, F_OIDEQ,
    1292             :                 ObjectIdGetDatum(object->classId));
    1293      173548 :     ScanKeyInit(&key[1],
    1294             :                 Anum_pg_depend_objid,
    1295             :                 BTEqualStrategyNumber, F_OIDEQ,
    1296             :                 ObjectIdGetDatum(object->objectId));
    1297      173548 :     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      171558 :         nkeys = 2;
    1307             : 
    1308      173548 :     scan = systable_beginscan(*depRel, DependDependerIndexId, true,
    1309             :                               NULL, nkeys, key);
    1310             : 
    1311      417562 :     while (HeapTupleIsValid(tup = systable_getnext(scan)))
    1312             :     {
    1313      244014 :         CatalogTupleDelete(*depRel, &tup->t_self);
    1314             :     }
    1315             : 
    1316      173548 :     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      173548 :     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.)
    1330             :      */
    1331      173548 :     DeleteComments(object->objectId, object->classId, object->objectSubId);
    1332      173548 :     DeleteSecurityLabel(object);
    1333      173548 :     DeleteInitPrivs(object);
    1334             : 
    1335             :     /*
    1336             :      * CommandCounterIncrement here to ensure that preceding changes are all
    1337             :      * visible to the next deletion step.
    1338             :      */
    1339      173548 :     CommandCounterIncrement();
    1340             : 
    1341             :     /*
    1342             :      * And we're done!
    1343             :      */
    1344      173548 : }
    1345             : 
    1346             : /*
    1347             :  * doDeletion: actually delete a single object
    1348             :  */
    1349             : static void
    1350      173552 : doDeletion(const ObjectAddress *object, int flags)
    1351             : {
    1352      173552 :     switch (object->classId)
    1353             :     {
    1354       65948 :         case RelationRelationId:
    1355             :             {
    1356       65948 :                 char        relKind = get_rel_relkind(object->objectId);
    1357             : 
    1358       65948 :                 if (relKind == RELKIND_INDEX ||
    1359             :                     relKind == RELKIND_PARTITIONED_INDEX)
    1360       22272 :                 {
    1361       22272 :                     bool        concurrent = ((flags & PERFORM_DELETION_CONCURRENTLY) != 0);
    1362       22272 :                     bool        concurrent_lock_mode = ((flags & PERFORM_DELETION_CONCURRENT_LOCK) != 0);
    1363             : 
    1364             :                     Assert(object->objectSubId == 0);
    1365       22272 :                     index_drop(object->objectId, concurrent, concurrent_lock_mode);
    1366             :                 }
    1367             :                 else
    1368             :                 {
    1369       43676 :                     if (object->objectSubId != 0)
    1370        1990 :                         RemoveAttributeById(object->objectId,
    1371        1990 :                                             object->objectSubId);
    1372             :                     else
    1373       41686 :                         heap_drop_with_catalog(object->objectId);
    1374             :                 }
    1375             : 
    1376             :                 /*
    1377             :                  * for a sequence, in addition to dropping the heap, also
    1378             :                  * delete pg_sequence tuple
    1379             :                  */
    1380       65948 :                 if (relKind == RELKIND_SEQUENCE)
    1381         920 :                     DeleteSequenceTuple(object->objectId);
    1382       65948 :                 break;
    1383             :             }
    1384             : 
    1385        6376 :         case ProcedureRelationId:
    1386        6376 :             RemoveFunctionById(object->objectId);
    1387        6376 :             break;
    1388             : 
    1389       65198 :         case TypeRelationId:
    1390       65198 :             RemoveTypeById(object->objectId);
    1391       65198 :             break;
    1392             : 
    1393       12050 :         case ConstraintRelationId:
    1394       12050 :             RemoveConstraintById(object->objectId);
    1395       12048 :             break;
    1396             : 
    1397        2974 :         case AttrDefaultRelationId:
    1398        2974 :             RemoveAttrDefaultById(object->objectId);
    1399        2974 :             break;
    1400             : 
    1401          88 :         case LargeObjectRelationId:
    1402          88 :             LargeObjectDrop(object->objectId);
    1403          88 :             break;
    1404             : 
    1405         734 :         case OperatorRelationId:
    1406         734 :             RemoveOperatorById(object->objectId);
    1407         734 :             break;
    1408             : 
    1409        2758 :         case RewriteRelationId:
    1410        2758 :             RemoveRewriteRuleById(object->objectId);
    1411        2756 :             break;
    1412             : 
    1413       11728 :         case TriggerRelationId:
    1414       11728 :             RemoveTriggerById(object->objectId);
    1415       11728 :             break;
    1416             : 
    1417         466 :         case StatisticExtRelationId:
    1418         466 :             RemoveStatisticsById(object->objectId);
    1419         466 :             break;
    1420             : 
    1421          48 :         case TSConfigRelationId:
    1422          48 :             RemoveTSConfigurationById(object->objectId);
    1423          48 :             break;
    1424             : 
    1425         106 :         case ExtensionRelationId:
    1426         106 :             RemoveExtensionById(object->objectId);
    1427         106 :             break;
    1428             : 
    1429         540 :         case PolicyRelationId:
    1430         540 :             RemovePolicyById(object->objectId);
    1431         540 :             break;
    1432             : 
    1433         192 :         case PublicationNamespaceRelationId:
    1434         192 :             RemovePublicationSchemaById(object->objectId);
    1435         192 :             break;
    1436             : 
    1437         760 :         case PublicationRelRelationId:
    1438         760 :             RemovePublicationRelById(object->objectId);
    1439         760 :             break;
    1440             : 
    1441         370 :         case PublicationRelationId:
    1442         370 :             RemovePublicationById(object->objectId);
    1443         370 :             break;
    1444             : 
    1445        3216 :         case CastRelationId:
    1446             :         case CollationRelationId:
    1447             :         case ConversionRelationId:
    1448             :         case LanguageRelationId:
    1449             :         case OperatorClassRelationId:
    1450             :         case OperatorFamilyRelationId:
    1451             :         case AccessMethodRelationId:
    1452             :         case AccessMethodOperatorRelationId:
    1453             :         case AccessMethodProcedureRelationId:
    1454             :         case NamespaceRelationId:
    1455             :         case TSParserRelationId:
    1456             :         case TSDictionaryRelationId:
    1457             :         case TSTemplateRelationId:
    1458             :         case ForeignDataWrapperRelationId:
    1459             :         case ForeignServerRelationId:
    1460             :         case UserMappingRelationId:
    1461             :         case DefaultAclRelationId:
    1462             :         case EventTriggerRelationId:
    1463             :         case TransformRelationId:
    1464             :         case AuthMemRelationId:
    1465        3216 :             DropObjectById(object);
    1466        3216 :             break;
    1467             : 
    1468             :             /*
    1469             :              * These global object types are not supported here.
    1470             :              */
    1471           0 :         case AuthIdRelationId:
    1472             :         case DatabaseRelationId:
    1473             :         case TableSpaceRelationId:
    1474             :         case SubscriptionRelationId:
    1475             :         case ParameterAclRelationId:
    1476           0 :             elog(ERROR, "global objects cannot be deleted by doDeletion");
    1477             :             break;
    1478             : 
    1479           0 :         default:
    1480           0 :             elog(ERROR, "unsupported object class: %u", object->classId);
    1481             :     }
    1482      173548 : }
    1483             : 
    1484             : /*
    1485             :  * AcquireDeletionLock - acquire a suitable lock for deleting an object
    1486             :  *
    1487             :  * Accepts the same flags as performDeletion (though currently only
    1488             :  * PERFORM_DELETION_CONCURRENTLY does anything).
    1489             :  *
    1490             :  * We use LockRelation for relations, and otherwise LockSharedObject or
    1491             :  * LockDatabaseObject as appropriate for the object type.
    1492             :  */
    1493             : void
    1494      221006 : AcquireDeletionLock(const ObjectAddress *object, int flags)
    1495             : {
    1496      221006 :     if (object->classId == RelationRelationId)
    1497             :     {
    1498             :         /*
    1499             :          * In DROP INDEX CONCURRENTLY, take only ShareUpdateExclusiveLock on
    1500             :          * the index for the moment.  index_drop() will promote the lock once
    1501             :          * it's safe to do so.  In all other cases we need full exclusive
    1502             :          * lock.
    1503             :          */
    1504       83882 :         if (flags & PERFORM_DELETION_CONCURRENTLY)
    1505          80 :             LockRelationOid(object->objectId, ShareUpdateExclusiveLock);
    1506             :         else
    1507       83802 :             LockRelationOid(object->objectId, AccessExclusiveLock);
    1508             :     }
    1509      137124 :     else if (object->classId == AuthMemRelationId)
    1510          12 :         LockSharedObject(object->classId, object->objectId, 0,
    1511             :                          AccessExclusiveLock);
    1512             :     else
    1513             :     {
    1514             :         /* assume we should lock the whole object not a sub-object */
    1515      137112 :         LockDatabaseObject(object->classId, object->objectId, 0,
    1516             :                            AccessExclusiveLock);
    1517             :     }
    1518      221006 : }
    1519             : 
    1520             : /*
    1521             :  * ReleaseDeletionLock - release an object deletion lock
    1522             :  *
    1523             :  * Companion to AcquireDeletionLock.
    1524             :  */
    1525             : void
    1526        1442 : ReleaseDeletionLock(const ObjectAddress *object)
    1527             : {
    1528        1442 :     if (object->classId == RelationRelationId)
    1529          44 :         UnlockRelationOid(object->objectId, AccessExclusiveLock);
    1530             :     else
    1531             :         /* assume we should lock the whole object not a sub-object */
    1532        1398 :         UnlockDatabaseObject(object->classId, object->objectId, 0,
    1533             :                              AccessExclusiveLock);
    1534        1442 : }
    1535             : 
    1536             : /*
    1537             :  * recordDependencyOnExpr - find expression dependencies
    1538             :  *
    1539             :  * This is used to find the dependencies of rules, constraint expressions,
    1540             :  * etc.
    1541             :  *
    1542             :  * Given an expression or query in node-tree form, find all the objects
    1543             :  * it refers to (tables, columns, operators, functions, etc).  Record
    1544             :  * a dependency of the specified type from the given depender object
    1545             :  * to each object mentioned in the expression.
    1546             :  *
    1547             :  * rtable is the rangetable to be used to interpret Vars with varlevelsup=0.
    1548             :  * It can be NIL if no such variables are expected.
    1549             :  */
    1550             : void
    1551       24144 : recordDependencyOnExpr(const ObjectAddress *depender,
    1552             :                        Node *expr, List *rtable,
    1553             :                        DependencyType behavior)
    1554             : {
    1555             :     find_expr_references_context context;
    1556             : 
    1557       24144 :     context.addrs = new_object_addresses();
    1558             : 
    1559             :     /* Set up interpretation for Vars at varlevelsup = 0 */
    1560       24144 :     context.rtables = list_make1(rtable);
    1561             : 
    1562             :     /* Scan the expression tree for referenceable objects */
    1563       24144 :     find_expr_references_walker(expr, &context);
    1564             : 
    1565             :     /* Remove any duplicates */
    1566       24144 :     eliminate_duplicate_dependencies(context.addrs);
    1567             : 
    1568             :     /* And record 'em */
    1569       24144 :     recordMultipleDependencies(depender,
    1570       24144 :                                context.addrs->refs, context.addrs->numrefs,
    1571             :                                behavior);
    1572             : 
    1573       24144 :     free_object_addresses(context.addrs);
    1574       24144 : }
    1575             : 
    1576             : /*
    1577             :  * recordDependencyOnSingleRelExpr - find expression dependencies
    1578             :  *
    1579             :  * As above, but only one relation is expected to be referenced (with
    1580             :  * varno = 1 and varlevelsup = 0).  Pass the relation OID instead of a
    1581             :  * range table.  An additional frammish is that dependencies on that
    1582             :  * relation's component columns will be marked with 'self_behavior',
    1583             :  * whereas 'behavior' is used for everything else; also, if 'reverse_self'
    1584             :  * is true, those dependencies are reversed so that the columns are made
    1585             :  * to depend on the table not vice versa.
    1586             :  *
    1587             :  * NOTE: the caller should ensure that a whole-table dependency on the
    1588             :  * specified relation is created separately, if one is needed.  In particular,
    1589             :  * a whole-row Var "relation.*" will not cause this routine to emit any
    1590             :  * dependency item.  This is appropriate behavior for subexpressions of an
    1591             :  * ordinary query, so other cases need to cope as necessary.
    1592             :  */
    1593             : void
    1594        8488 : recordDependencyOnSingleRelExpr(const ObjectAddress *depender,
    1595             :                                 Node *expr, Oid relId,
    1596             :                                 DependencyType behavior,
    1597             :                                 DependencyType self_behavior,
    1598             :                                 bool reverse_self)
    1599             : {
    1600             :     find_expr_references_context context;
    1601        8488 :     RangeTblEntry rte = {0};
    1602             : 
    1603        8488 :     context.addrs = new_object_addresses();
    1604             : 
    1605             :     /* We gin up a rather bogus rangetable list to handle Vars */
    1606        8488 :     rte.type = T_RangeTblEntry;
    1607        8488 :     rte.rtekind = RTE_RELATION;
    1608        8488 :     rte.relid = relId;
    1609        8488 :     rte.relkind = RELKIND_RELATION; /* no need for exactness here */
    1610        8488 :     rte.rellockmode = AccessShareLock;
    1611             : 
    1612        8488 :     context.rtables = list_make1(list_make1(&rte));
    1613             : 
    1614             :     /* Scan the expression tree for referenceable objects */
    1615        8488 :     find_expr_references_walker(expr, &context);
    1616             : 
    1617             :     /* Remove any duplicates */
    1618        8488 :     eliminate_duplicate_dependencies(context.addrs);
    1619             : 
    1620             :     /* Separate self-dependencies if necessary */
    1621        8488 :     if ((behavior != self_behavior || reverse_self) &&
    1622        1638 :         context.addrs->numrefs > 0)
    1623             :     {
    1624             :         ObjectAddresses *self_addrs;
    1625             :         ObjectAddress *outobj;
    1626             :         int         oldref,
    1627             :                     outrefs;
    1628             : 
    1629        1632 :         self_addrs = new_object_addresses();
    1630             : 
    1631        1632 :         outobj = context.addrs->refs;
    1632        1632 :         outrefs = 0;
    1633        6826 :         for (oldref = 0; oldref < context.addrs->numrefs; oldref++)
    1634             :         {
    1635        5194 :             ObjectAddress *thisobj = context.addrs->refs + oldref;
    1636             : 
    1637        5194 :             if (thisobj->classId == RelationRelationId &&
    1638        2068 :                 thisobj->objectId == relId)
    1639             :             {
    1640             :                 /* Move this ref into self_addrs */
    1641        2068 :                 add_exact_object_address(thisobj, self_addrs);
    1642             :             }
    1643             :             else
    1644             :             {
    1645             :                 /* Keep it in context.addrs */
    1646        3126 :                 *outobj = *thisobj;
    1647        3126 :                 outobj++;
    1648        3126 :                 outrefs++;
    1649             :             }
    1650             :         }
    1651        1632 :         context.addrs->numrefs = outrefs;
    1652             : 
    1653             :         /* Record the self-dependencies with the appropriate direction */
    1654        1632 :         if (!reverse_self)
    1655        1424 :             recordMultipleDependencies(depender,
    1656        1424 :                                        self_addrs->refs, self_addrs->numrefs,
    1657             :                                        self_behavior);
    1658             :         else
    1659             :         {
    1660             :             /* Can't use recordMultipleDependencies, so do it the hard way */
    1661             :             int         selfref;
    1662             : 
    1663         498 :             for (selfref = 0; selfref < self_addrs->numrefs; selfref++)
    1664             :             {
    1665         290 :                 ObjectAddress *thisobj = self_addrs->refs + selfref;
    1666             : 
    1667         290 :                 recordDependencyOn(thisobj, depender, self_behavior);
    1668             :             }
    1669             :         }
    1670             : 
    1671        1632 :         free_object_addresses(self_addrs);
    1672             :     }
    1673             : 
    1674             :     /* Record the external dependencies */
    1675        8488 :     recordMultipleDependencies(depender,
    1676        8488 :                                context.addrs->refs, context.addrs->numrefs,
    1677             :                                behavior);
    1678             : 
    1679        8488 :     free_object_addresses(context.addrs);
    1680        8488 : }
    1681             : 
    1682             : /*
    1683             :  * Recursively search an expression tree for object references.
    1684             :  *
    1685             :  * Note: in many cases we do not need to create dependencies on the datatypes
    1686             :  * involved in an expression, because we'll have an indirect dependency via
    1687             :  * some other object.  For instance Var nodes depend on a column which depends
    1688             :  * on the datatype, and OpExpr nodes depend on the operator which depends on
    1689             :  * the datatype.  However we do need a type dependency if there is no such
    1690             :  * indirect dependency, as for example in Const and CoerceToDomain nodes.
    1691             :  *
    1692             :  * Similarly, we don't need to create dependencies on collations except where
    1693             :  * the collation is being freshly introduced to the expression.
    1694             :  */
    1695             : static bool
    1696     1618356 : find_expr_references_walker(Node *node,
    1697             :                             find_expr_references_context *context)
    1698             : {
    1699     1618356 :     if (node == NULL)
    1700      560872 :         return false;
    1701     1057484 :     if (IsA(node, Var))
    1702             :     {
    1703      256860 :         Var        *var = (Var *) node;
    1704             :         List       *rtable;
    1705             :         RangeTblEntry *rte;
    1706             : 
    1707             :         /* Find matching rtable entry, or complain if not found */
    1708      256860 :         if (var->varlevelsup >= list_length(context->rtables))
    1709           0 :             elog(ERROR, "invalid varlevelsup %d", var->varlevelsup);
    1710      256860 :         rtable = (List *) list_nth(context->rtables, var->varlevelsup);
    1711      256860 :         if (var->varno <= 0 || var->varno > list_length(rtable))
    1712           0 :             elog(ERROR, "invalid varno %d", var->varno);
    1713      256860 :         rte = rt_fetch(var->varno, rtable);
    1714             : 
    1715             :         /*
    1716             :          * A whole-row Var references no specific columns, so adds no new
    1717             :          * dependency.  (We assume that there is a whole-table dependency
    1718             :          * arising from each underlying rangetable entry.  While we could
    1719             :          * record such a dependency when finding a whole-row Var that
    1720             :          * references a relation directly, it's quite unclear how to extend
    1721             :          * that to whole-row Vars for JOINs, so it seems better to leave the
    1722             :          * responsibility with the range table.  Note that this poses some
    1723             :          * risks for identifying dependencies of stand-alone expressions:
    1724             :          * whole-table references may need to be created separately.)
    1725             :          */
    1726      256860 :         if (var->varattno == InvalidAttrNumber)
    1727        4414 :             return false;
    1728      252446 :         if (rte->rtekind == RTE_RELATION)
    1729             :         {
    1730             :             /* If it's a plain relation, reference this column */
    1731      187684 :             add_object_address(RelationRelationId, rte->relid, var->varattno,
    1732             :                                context->addrs);
    1733             :         }
    1734       64762 :         else if (rte->rtekind == RTE_FUNCTION)
    1735             :         {
    1736             :             /* Might need to add a dependency on a composite type's column */
    1737             :             /* (done out of line, because it's a bit bulky) */
    1738       32636 :             process_function_rte_ref(rte, var->varattno, context);
    1739             :         }
    1740             : 
    1741             :         /*
    1742             :          * Vars referencing other RTE types require no additional work.  In
    1743             :          * particular, a join alias Var can be ignored, because it must
    1744             :          * reference a merged USING column.  The relevant join input columns
    1745             :          * will also be referenced in the join qual, and any type coercion
    1746             :          * functions involved in the alias expression will be dealt with when
    1747             :          * we scan the RTE itself.
    1748             :          */
    1749      252446 :         return false;
    1750             :     }
    1751      800624 :     else if (IsA(node, Const))
    1752             :     {
    1753      133150 :         Const      *con = (Const *) node;
    1754             :         Oid         objoid;
    1755             : 
    1756             :         /* A constant must depend on the constant's datatype */
    1757      133150 :         add_object_address(TypeRelationId, con->consttype, 0,
    1758             :                            context->addrs);
    1759             : 
    1760             :         /*
    1761             :          * We must also depend on the constant's collation: it could be
    1762             :          * different from the datatype's, if a CollateExpr was const-folded to
    1763             :          * a simple constant.  However we can save work in the most common
    1764             :          * case where the collation is "default", since we know that's pinned.
    1765             :          */
    1766      133150 :         if (OidIsValid(con->constcollid) &&
    1767       52052 :             con->constcollid != DEFAULT_COLLATION_OID)
    1768       12486 :             add_object_address(CollationRelationId, con->constcollid, 0,
    1769             :                                context->addrs);
    1770             : 
    1771             :         /*
    1772             :          * If it's a regclass or similar literal referring to an existing
    1773             :          * object, add a reference to that object.  (Currently, only the
    1774             :          * regclass and regconfig cases have any likely use, but we may as
    1775             :          * well handle all the OID-alias datatypes consistently.)
    1776             :          */
    1777      133150 :         if (!con->constisnull)
    1778             :         {
    1779      113388 :             switch (con->consttype)
    1780             :             {
    1781           0 :                 case REGPROCOID:
    1782             :                 case REGPROCEDUREOID:
    1783           0 :                     objoid = DatumGetObjectId(con->constvalue);
    1784           0 :                     if (SearchSysCacheExists1(PROCOID,
    1785             :                                               ObjectIdGetDatum(objoid)))
    1786           0 :                         add_object_address(ProcedureRelationId, objoid, 0,
    1787             :                                            context->addrs);
    1788           0 :                     break;
    1789           0 :                 case REGOPEROID:
    1790             :                 case REGOPERATOROID:
    1791           0 :                     objoid = DatumGetObjectId(con->constvalue);
    1792           0 :                     if (SearchSysCacheExists1(OPEROID,
    1793             :                                               ObjectIdGetDatum(objoid)))
    1794           0 :                         add_object_address(OperatorRelationId, objoid, 0,
    1795             :                                            context->addrs);
    1796           0 :                     break;
    1797        3650 :                 case REGCLASSOID:
    1798        3650 :                     objoid = DatumGetObjectId(con->constvalue);
    1799        3650 :                     if (SearchSysCacheExists1(RELOID,
    1800             :                                               ObjectIdGetDatum(objoid)))
    1801        3650 :                         add_object_address(RelationRelationId, objoid, 0,
    1802             :                                            context->addrs);
    1803        3650 :                     break;
    1804           0 :                 case REGTYPEOID:
    1805           0 :                     objoid = DatumGetObjectId(con->constvalue);
    1806           0 :                     if (SearchSysCacheExists1(TYPEOID,
    1807             :                                               ObjectIdGetDatum(objoid)))
    1808           0 :                         add_object_address(TypeRelationId, objoid, 0,
    1809             :                                            context->addrs);
    1810           0 :                     break;
    1811           0 :                 case REGCOLLATIONOID:
    1812           0 :                     objoid = DatumGetObjectId(con->constvalue);
    1813           0 :                     if (SearchSysCacheExists1(COLLOID,
    1814             :                                               ObjectIdGetDatum(objoid)))
    1815           0 :                         add_object_address(CollationRelationId, objoid, 0,
    1816             :                                            context->addrs);
    1817           0 :                     break;
    1818           0 :                 case REGCONFIGOID:
    1819           0 :                     objoid = DatumGetObjectId(con->constvalue);
    1820           0 :                     if (SearchSysCacheExists1(TSCONFIGOID,
    1821             :                                               ObjectIdGetDatum(objoid)))
    1822           0 :                         add_object_address(TSConfigRelationId, objoid, 0,
    1823             :                                            context->addrs);
    1824           0 :                     break;
    1825           0 :                 case REGDICTIONARYOID:
    1826           0 :                     objoid = DatumGetObjectId(con->constvalue);
    1827           0 :                     if (SearchSysCacheExists1(TSDICTOID,
    1828             :                                               ObjectIdGetDatum(objoid)))
    1829           0 :                         add_object_address(TSDictionaryRelationId, objoid, 0,
    1830             :                                            context->addrs);
    1831           0 :                     break;
    1832             : 
    1833         152 :                 case REGNAMESPACEOID:
    1834         152 :                     objoid = DatumGetObjectId(con->constvalue);
    1835         152 :                     if (SearchSysCacheExists1(NAMESPACEOID,
    1836             :                                               ObjectIdGetDatum(objoid)))
    1837         152 :                         add_object_address(NamespaceRelationId, objoid, 0,
    1838             :                                            context->addrs);
    1839         152 :                     break;
    1840             : 
    1841             :                     /*
    1842             :                      * Dependencies for regrole should be shared among all
    1843             :                      * databases, so explicitly inhibit to have dependencies.
    1844             :                      */
    1845           0 :                 case REGROLEOID:
    1846           0 :                     ereport(ERROR,
    1847             :                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1848             :                              errmsg("constant of the type %s cannot be used here",
    1849             :                                     "regrole")));
    1850             :                     break;
    1851             :             }
    1852       19762 :         }
    1853      133150 :         return false;
    1854             :     }
    1855      667474 :     else if (IsA(node, Param))
    1856             :     {
    1857       12600 :         Param      *param = (Param *) node;
    1858             : 
    1859             :         /* A parameter must depend on the parameter's datatype */
    1860       12600 :         add_object_address(TypeRelationId, param->paramtype, 0,
    1861             :                            context->addrs);
    1862             :         /* and its collation, just as for Consts */
    1863       12600 :         if (OidIsValid(param->paramcollid) &&
    1864        2096 :             param->paramcollid != DEFAULT_COLLATION_OID)
    1865        1216 :             add_object_address(CollationRelationId, param->paramcollid, 0,
    1866             :                                context->addrs);
    1867             :     }
    1868      654874 :     else if (IsA(node, FuncExpr))
    1869             :     {
    1870       65032 :         FuncExpr   *funcexpr = (FuncExpr *) node;
    1871             : 
    1872       65032 :         add_object_address(ProcedureRelationId, funcexpr->funcid, 0,
    1873             :                            context->addrs);
    1874             :         /* fall through to examine arguments */
    1875             :     }
    1876      589842 :     else if (IsA(node, OpExpr))
    1877             :     {
    1878       74692 :         OpExpr     *opexpr = (OpExpr *) node;
    1879             : 
    1880       74692 :         add_object_address(OperatorRelationId, opexpr->opno, 0,
    1881             :                            context->addrs);
    1882             :         /* fall through to examine arguments */
    1883             :     }
    1884      515150 :     else if (IsA(node, DistinctExpr))
    1885             :     {
    1886          12 :         DistinctExpr *distinctexpr = (DistinctExpr *) node;
    1887             : 
    1888          12 :         add_object_address(OperatorRelationId, distinctexpr->opno, 0,
    1889             :                            context->addrs);
    1890             :         /* fall through to examine arguments */
    1891             :     }
    1892      515138 :     else if (IsA(node, NullIfExpr))
    1893             :     {
    1894         104 :         NullIfExpr *nullifexpr = (NullIfExpr *) node;
    1895             : 
    1896         104 :         add_object_address(OperatorRelationId, nullifexpr->opno, 0,
    1897             :                            context->addrs);
    1898             :         /* fall through to examine arguments */
    1899             :     }
    1900      515034 :     else if (IsA(node, ScalarArrayOpExpr))
    1901             :     {
    1902        5404 :         ScalarArrayOpExpr *opexpr = (ScalarArrayOpExpr *) node;
    1903             : 
    1904        5404 :         add_object_address(OperatorRelationId, opexpr->opno, 0,
    1905             :                            context->addrs);
    1906             :         /* fall through to examine arguments */
    1907             :     }
    1908      509630 :     else if (IsA(node, Aggref))
    1909             :     {
    1910        1478 :         Aggref     *aggref = (Aggref *) node;
    1911             : 
    1912        1478 :         add_object_address(ProcedureRelationId, aggref->aggfnoid, 0,
    1913             :                            context->addrs);
    1914             :         /* fall through to examine arguments */
    1915             :     }
    1916      508152 :     else if (IsA(node, WindowFunc))
    1917             :     {
    1918         136 :         WindowFunc *wfunc = (WindowFunc *) node;
    1919             : 
    1920         136 :         add_object_address(ProcedureRelationId, wfunc->winfnoid, 0,
    1921             :                            context->addrs);
    1922             :         /* fall through to examine arguments */
    1923             :     }
    1924      508016 :     else if (IsA(node, SubscriptingRef))
    1925             :     {
    1926        2062 :         SubscriptingRef *sbsref = (SubscriptingRef *) node;
    1927             : 
    1928             :         /*
    1929             :          * The refexpr should provide adequate dependency on refcontainertype,
    1930             :          * and that type in turn depends on refelemtype.  However, a custom
    1931             :          * subscripting handler might set refrestype to something different
    1932             :          * from either of those, in which case we'd better record it.
    1933             :          */
    1934        2062 :         if (sbsref->refrestype != sbsref->refcontainertype &&
    1935        1936 :             sbsref->refrestype != sbsref->refelemtype)
    1936           0 :             add_object_address(TypeRelationId, sbsref->refrestype, 0,
    1937             :                                context->addrs);
    1938             :         /* fall through to examine arguments */
    1939             :     }
    1940      505954 :     else if (IsA(node, SubPlan))
    1941             :     {
    1942             :         /* Extra work needed here if we ever need this case */
    1943           0 :         elog(ERROR, "already-planned subqueries not supported");
    1944             :     }
    1945      505954 :     else if (IsA(node, FieldSelect))
    1946             :     {
    1947       11008 :         FieldSelect *fselect = (FieldSelect *) node;
    1948       11008 :         Oid         argtype = getBaseType(exprType((Node *) fselect->arg));
    1949       11008 :         Oid         reltype = get_typ_typrelid(argtype);
    1950             : 
    1951             :         /*
    1952             :          * We need a dependency on the specific column named in FieldSelect,
    1953             :          * assuming we can identify the pg_class OID for it.  (Probably we
    1954             :          * always can at the moment, but in future it might be possible for
    1955             :          * argtype to be RECORDOID.)  If we can make a column dependency then
    1956             :          * we shouldn't need a dependency on the column's type; but if we
    1957             :          * can't, make a dependency on the type, as it might not appear
    1958             :          * anywhere else in the expression.
    1959             :          */
    1960       11008 :         if (OidIsValid(reltype))
    1961        6184 :             add_object_address(RelationRelationId, reltype, fselect->fieldnum,
    1962             :                                context->addrs);
    1963             :         else
    1964        4824 :             add_object_address(TypeRelationId, fselect->resulttype, 0,
    1965             :                                context->addrs);
    1966             :         /* the collation might not be referenced anywhere else, either */
    1967       11008 :         if (OidIsValid(fselect->resultcollid) &&
    1968        1314 :             fselect->resultcollid != DEFAULT_COLLATION_OID)
    1969           0 :             add_object_address(CollationRelationId, fselect->resultcollid, 0,
    1970             :                                context->addrs);
    1971             :     }
    1972      494946 :     else if (IsA(node, FieldStore))
    1973             :     {
    1974          96 :         FieldStore *fstore = (FieldStore *) node;
    1975          96 :         Oid         reltype = get_typ_typrelid(fstore->resulttype);
    1976             : 
    1977             :         /* similar considerations to FieldSelect, but multiple column(s) */
    1978          96 :         if (OidIsValid(reltype))
    1979             :         {
    1980             :             ListCell   *l;
    1981             : 
    1982         192 :             foreach(l, fstore->fieldnums)
    1983          96 :                 add_object_address(RelationRelationId, reltype, lfirst_int(l),
    1984             :                                    context->addrs);
    1985             :         }
    1986             :         else
    1987           0 :             add_object_address(TypeRelationId, fstore->resulttype, 0,
    1988             :                                context->addrs);
    1989             :     }
    1990      494850 :     else if (IsA(node, RelabelType))
    1991             :     {
    1992       11076 :         RelabelType *relab = (RelabelType *) node;
    1993             : 
    1994             :         /* since there is no function dependency, need to depend on type */
    1995       11076 :         add_object_address(TypeRelationId, relab->resulttype, 0,
    1996             :                            context->addrs);
    1997             :         /* the collation might not be referenced anywhere else, either */
    1998       11076 :         if (OidIsValid(relab->resultcollid) &&
    1999        2538 :             relab->resultcollid != DEFAULT_COLLATION_OID)
    2000        2204 :             add_object_address(CollationRelationId, relab->resultcollid, 0,
    2001             :                                context->addrs);
    2002             :     }
    2003      483774 :     else if (IsA(node, CoerceViaIO))
    2004             :     {
    2005        2584 :         CoerceViaIO *iocoerce = (CoerceViaIO *) node;
    2006             : 
    2007             :         /* since there is no exposed function, need to depend on type */
    2008        2584 :         add_object_address(TypeRelationId, iocoerce->resulttype, 0,
    2009             :                            context->addrs);
    2010             :         /* the collation might not be referenced anywhere else, either */
    2011        2584 :         if (OidIsValid(iocoerce->resultcollid) &&
    2012        2132 :             iocoerce->resultcollid != DEFAULT_COLLATION_OID)
    2013         532 :             add_object_address(CollationRelationId, iocoerce->resultcollid, 0,
    2014             :                                context->addrs);
    2015             :     }
    2016      481190 :     else if (IsA(node, ArrayCoerceExpr))
    2017             :     {
    2018         386 :         ArrayCoerceExpr *acoerce = (ArrayCoerceExpr *) node;
    2019             : 
    2020             :         /* as above, depend on type */
    2021         386 :         add_object_address(TypeRelationId, acoerce->resulttype, 0,
    2022             :                            context->addrs);
    2023             :         /* the collation might not be referenced anywhere else, either */
    2024         386 :         if (OidIsValid(acoerce->resultcollid) &&
    2025         158 :             acoerce->resultcollid != DEFAULT_COLLATION_OID)
    2026          76 :             add_object_address(CollationRelationId, acoerce->resultcollid, 0,
    2027             :                                context->addrs);
    2028             :         /* fall through to examine arguments */
    2029             :     }
    2030      480804 :     else if (IsA(node, ConvertRowtypeExpr))
    2031             :     {
    2032           0 :         ConvertRowtypeExpr *cvt = (ConvertRowtypeExpr *) node;
    2033             : 
    2034             :         /* since there is no function dependency, need to depend on type */
    2035           0 :         add_object_address(TypeRelationId, cvt->resulttype, 0,
    2036             :                            context->addrs);
    2037             :     }
    2038      480804 :     else if (IsA(node, CollateExpr))
    2039             :     {
    2040          84 :         CollateExpr *coll = (CollateExpr *) node;
    2041             : 
    2042          84 :         add_object_address(CollationRelationId, coll->collOid, 0,
    2043             :                            context->addrs);
    2044             :     }
    2045      480720 :     else if (IsA(node, RowExpr))
    2046             :     {
    2047          60 :         RowExpr    *rowexpr = (RowExpr *) node;
    2048             : 
    2049          60 :         add_object_address(TypeRelationId, rowexpr->row_typeid, 0,
    2050             :                            context->addrs);
    2051             :     }
    2052      480660 :     else if (IsA(node, RowCompareExpr))
    2053             :     {
    2054          18 :         RowCompareExpr *rcexpr = (RowCompareExpr *) node;
    2055             :         ListCell   *l;
    2056             : 
    2057          54 :         foreach(l, rcexpr->opnos)
    2058             :         {
    2059          36 :             add_object_address(OperatorRelationId, lfirst_oid(l), 0,
    2060             :                                context->addrs);
    2061             :         }
    2062          54 :         foreach(l, rcexpr->opfamilies)
    2063             :         {
    2064          36 :             add_object_address(OperatorFamilyRelationId, lfirst_oid(l), 0,
    2065             :                                context->addrs);
    2066             :         }
    2067             :         /* fall through to examine arguments */
    2068             :     }
    2069      480642 :     else if (IsA(node, CoerceToDomain))
    2070             :     {
    2071       49208 :         CoerceToDomain *cd = (CoerceToDomain *) node;
    2072             : 
    2073       49208 :         add_object_address(TypeRelationId, cd->resulttype, 0,
    2074             :                            context->addrs);
    2075             :     }
    2076      431434 :     else if (IsA(node, NextValueExpr))
    2077             :     {
    2078           0 :         NextValueExpr *nve = (NextValueExpr *) node;
    2079             : 
    2080           0 :         add_object_address(RelationRelationId, nve->seqid, 0,
    2081             :                            context->addrs);
    2082             :     }
    2083      431434 :     else if (IsA(node, OnConflictExpr))
    2084             :     {
    2085          18 :         OnConflictExpr *onconflict = (OnConflictExpr *) node;
    2086             : 
    2087          18 :         if (OidIsValid(onconflict->constraint))
    2088           0 :             add_object_address(ConstraintRelationId, onconflict->constraint, 0,
    2089             :                                context->addrs);
    2090             :         /* fall through to examine arguments */
    2091             :     }
    2092      431416 :     else if (IsA(node, SortGroupClause))
    2093             :     {
    2094        9998 :         SortGroupClause *sgc = (SortGroupClause *) node;
    2095             : 
    2096        9998 :         add_object_address(OperatorRelationId, sgc->eqop, 0,
    2097             :                            context->addrs);
    2098        9998 :         if (OidIsValid(sgc->sortop))
    2099        9998 :             add_object_address(OperatorRelationId, sgc->sortop, 0,
    2100             :                                context->addrs);
    2101        9998 :         return false;
    2102             :     }
    2103      421418 :     else if (IsA(node, WindowClause))
    2104             :     {
    2105         136 :         WindowClause *wc = (WindowClause *) node;
    2106             : 
    2107         136 :         if (OidIsValid(wc->startInRangeFunc))
    2108           6 :             add_object_address(ProcedureRelationId, wc->startInRangeFunc, 0,
    2109             :                                context->addrs);
    2110         136 :         if (OidIsValid(wc->endInRangeFunc))
    2111           6 :             add_object_address(ProcedureRelationId, wc->endInRangeFunc, 0,
    2112             :                                context->addrs);
    2113         136 :         if (OidIsValid(wc->inRangeColl) &&
    2114           0 :             wc->inRangeColl != DEFAULT_COLLATION_OID)
    2115           0 :             add_object_address(CollationRelationId, wc->inRangeColl, 0,
    2116             :                                context->addrs);
    2117             :         /* fall through to examine substructure */
    2118             :     }
    2119      421282 :     else if (IsA(node, CTECycleClause))
    2120             :     {
    2121          12 :         CTECycleClause *cc = (CTECycleClause *) node;
    2122             : 
    2123          12 :         if (OidIsValid(cc->cycle_mark_type))
    2124          12 :             add_object_address(TypeRelationId, cc->cycle_mark_type, 0,
    2125             :                                context->addrs);
    2126          12 :         if (OidIsValid(cc->cycle_mark_collation))
    2127           6 :             add_object_address(CollationRelationId, cc->cycle_mark_collation, 0,
    2128             :                                context->addrs);
    2129          12 :         if (OidIsValid(cc->cycle_mark_neop))
    2130          12 :             add_object_address(OperatorRelationId, cc->cycle_mark_neop, 0,
    2131             :                                context->addrs);
    2132             :         /* fall through to examine substructure */
    2133             :     }
    2134      421270 :     else if (IsA(node, Query))
    2135             :     {
    2136             :         /* Recurse into RTE subquery or not-yet-planned sublink subquery */
    2137       30154 :         Query      *query = (Query *) node;
    2138             :         ListCell   *lc;
    2139             :         bool        result;
    2140             : 
    2141             :         /*
    2142             :          * Add whole-relation refs for each plain relation mentioned in the
    2143             :          * subquery's rtable, and ensure we add refs for any type-coercion
    2144             :          * functions used in join alias lists.
    2145             :          *
    2146             :          * Note: query_tree_walker takes care of recursing into RTE_FUNCTION
    2147             :          * RTEs, subqueries, etc, so no need to do that here.  But we must
    2148             :          * tell it not to visit join alias lists, or we'll add refs for join
    2149             :          * input columns whether or not they are actually used in our query.
    2150             :          *
    2151             :          * Note: we don't need to worry about collations mentioned in
    2152             :          * RTE_VALUES or RTE_CTE RTEs, because those must just duplicate
    2153             :          * collations referenced in other parts of the Query.  We do have to
    2154             :          * worry about collations mentioned in RTE_FUNCTION, but we take care
    2155             :          * of those when we recurse to the RangeTblFunction node(s).
    2156             :          */
    2157       94568 :         foreach(lc, query->rtable)
    2158             :         {
    2159       64414 :             RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
    2160             : 
    2161       64414 :             switch (rte->rtekind)
    2162             :             {
    2163       40914 :                 case RTE_RELATION:
    2164       40914 :                     add_object_address(RelationRelationId, rte->relid, 0,
    2165             :                                        context->addrs);
    2166       40914 :                     break;
    2167       11586 :                 case RTE_JOIN:
    2168             : 
    2169             :                     /*
    2170             :                      * Examine joinaliasvars entries only for merged JOIN
    2171             :                      * USING columns.  Only those entries could contain
    2172             :                      * type-coercion functions.  Also, their join input
    2173             :                      * columns must be referenced in the join quals, so this
    2174             :                      * won't accidentally add refs to otherwise-unused join
    2175             :                      * input columns.  (We want to ref the type coercion
    2176             :                      * functions even if the merged column isn't explicitly
    2177             :                      * used anywhere, to protect possible expansion of the
    2178             :                      * join RTE as a whole-row var, and because it seems like
    2179             :                      * a bad idea to allow dropping a function that's present
    2180             :                      * in our query tree, whether or not it could get called.)
    2181             :                      */
    2182       11586 :                     context->rtables = lcons(query->rtable, context->rtables);
    2183       11786 :                     for (int i = 0; i < rte->joinmergedcols; i++)
    2184             :                     {
    2185         200 :                         Node       *aliasvar = list_nth(rte->joinaliasvars, i);
    2186             : 
    2187         200 :                         if (!IsA(aliasvar, Var))
    2188          48 :                             find_expr_references_walker(aliasvar, context);
    2189             :                     }
    2190       11586 :                     context->rtables = list_delete_first(context->rtables);
    2191       11586 :                     break;
    2192       11914 :                 default:
    2193       11914 :                     break;
    2194             :             }
    2195             :         }
    2196             : 
    2197             :         /*
    2198             :          * If the query is an INSERT or UPDATE, we should create a dependency
    2199             :          * on each target column, to prevent the specific target column from
    2200             :          * being dropped.  Although we will visit the TargetEntry nodes again
    2201             :          * during query_tree_walker, we won't have enough context to do this
    2202             :          * conveniently, so do it here.
    2203             :          */
    2204       30154 :         if (query->commandType == CMD_INSERT ||
    2205       29698 :             query->commandType == CMD_UPDATE)
    2206             :         {
    2207             :             RangeTblEntry *rte;
    2208             : 
    2209        1288 :             if (query->resultRelation <= 0 ||
    2210         644 :                 query->resultRelation > list_length(query->rtable))
    2211           0 :                 elog(ERROR, "invalid resultRelation %d",
    2212             :                      query->resultRelation);
    2213         644 :             rte = rt_fetch(query->resultRelation, query->rtable);
    2214         644 :             if (rte->rtekind == RTE_RELATION)
    2215             :             {
    2216        1986 :                 foreach(lc, query->targetList)
    2217             :                 {
    2218        1342 :                     TargetEntry *tle = (TargetEntry *) lfirst(lc);
    2219             : 
    2220        1342 :                     if (tle->resjunk)
    2221           6 :                         continue;   /* ignore junk tlist items */
    2222        1336 :                     add_object_address(RelationRelationId, rte->relid, tle->resno,
    2223             :                                        context->addrs);
    2224             :                 }
    2225             :             }
    2226             :         }
    2227             : 
    2228             :         /*
    2229             :          * Add dependencies on constraints listed in query's constraintDeps
    2230             :          */
    2231       30210 :         foreach(lc, query->constraintDeps)
    2232             :         {
    2233          56 :             add_object_address(ConstraintRelationId, lfirst_oid(lc), 0,
    2234             :                                context->addrs);
    2235             :         }
    2236             : 
    2237             :         /* Examine substructure of query */
    2238       30154 :         context->rtables = lcons(query->rtable, context->rtables);
    2239       30154 :         result = query_tree_walker(query,
    2240             :                                    find_expr_references_walker,
    2241             :                                    (void *) context,
    2242             :                                    QTW_IGNORE_JOINALIASES |
    2243             :                                    QTW_EXAMINE_SORTGROUP);
    2244       30154 :         context->rtables = list_delete_first(context->rtables);
    2245       30154 :         return result;
    2246             :     }
    2247      391116 :     else if (IsA(node, SetOperationStmt))
    2248             :     {
    2249        3072 :         SetOperationStmt *setop = (SetOperationStmt *) node;
    2250             : 
    2251             :         /* we need to look at the groupClauses for operator references */
    2252        3072 :         find_expr_references_walker((Node *) setop->groupClauses, context);
    2253             :         /* fall through to examine child nodes */
    2254             :     }
    2255      388044 :     else if (IsA(node, RangeTblFunction))
    2256             :     {
    2257        3936 :         RangeTblFunction *rtfunc = (RangeTblFunction *) node;
    2258             :         ListCell   *ct;
    2259             : 
    2260             :         /*
    2261             :          * Add refs for any datatypes and collations used in a column
    2262             :          * definition list for a RECORD function.  (For other cases, it should
    2263             :          * be enough to depend on the function itself.)
    2264             :          */
    2265        4044 :         foreach(ct, rtfunc->funccoltypes)
    2266             :         {
    2267         108 :             add_object_address(TypeRelationId, lfirst_oid(ct), 0,
    2268             :                                context->addrs);
    2269             :         }
    2270        4044 :         foreach(ct, rtfunc->funccolcollations)
    2271             :         {
    2272         108 :             Oid         collid = lfirst_oid(ct);
    2273             : 
    2274         108 :             if (OidIsValid(collid) && collid != DEFAULT_COLLATION_OID)
    2275           0 :                 add_object_address(CollationRelationId, collid, 0,
    2276             :                                    context->addrs);
    2277             :         }
    2278             :     }
    2279      384108 :     else if (IsA(node, TableFunc))
    2280             :     {
    2281          58 :         TableFunc  *tf = (TableFunc *) node;
    2282             :         ListCell   *ct;
    2283             : 
    2284             :         /*
    2285             :          * Add refs for the datatypes and collations used in the TableFunc.
    2286             :          */
    2287         340 :         foreach(ct, tf->coltypes)
    2288             :         {
    2289         282 :             add_object_address(TypeRelationId, lfirst_oid(ct), 0,
    2290             :                                context->addrs);
    2291             :         }
    2292         340 :         foreach(ct, tf->colcollations)
    2293             :         {
    2294         282 :             Oid         collid = lfirst_oid(ct);
    2295             : 
    2296         282 :             if (OidIsValid(collid) && collid != DEFAULT_COLLATION_OID)
    2297           0 :                 add_object_address(CollationRelationId, collid, 0,
    2298             :                                    context->addrs);
    2299             :         }
    2300             :     }
    2301      384050 :     else if (IsA(node, TableSampleClause))
    2302             :     {
    2303          20 :         TableSampleClause *tsc = (TableSampleClause *) node;
    2304             : 
    2305          20 :         add_object_address(ProcedureRelationId, tsc->tsmhandler, 0,
    2306             :                            context->addrs);
    2307             :         /* fall through to examine arguments */
    2308             :     }
    2309             : 
    2310      627322 :     return expression_tree_walker(node, find_expr_references_walker,
    2311             :                                   (void *) context);
    2312             : }
    2313             : 
    2314             : /*
    2315             :  * find_expr_references_walker subroutine: handle a Var reference
    2316             :  * to an RTE_FUNCTION RTE
    2317             :  */
    2318             : static void
    2319       32636 : process_function_rte_ref(RangeTblEntry *rte, AttrNumber attnum,
    2320             :                          find_expr_references_context *context)
    2321             : {
    2322       32636 :     int         atts_done = 0;
    2323             :     ListCell   *lc;
    2324             : 
    2325             :     /*
    2326             :      * Identify which RangeTblFunction produces this attnum, and see if it
    2327             :      * returns a composite type.  If so, we'd better make a dependency on the
    2328             :      * referenced column of the composite type (or actually, of its associated
    2329             :      * relation).
    2330             :      */
    2331       32858 :     foreach(lc, rte->functions)
    2332             :     {
    2333       32768 :         RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc);
    2334             : 
    2335       32768 :         if (attnum > atts_done &&
    2336       32768 :             attnum <= atts_done + rtfunc->funccolcount)
    2337             :         {
    2338             :             TupleDesc   tupdesc;
    2339             : 
    2340             :             /* If it has a coldeflist, it certainly returns RECORD */
    2341       32546 :             if (rtfunc->funccolnames != NIL)
    2342         108 :                 tupdesc = NULL; /* no need to work hard */
    2343             :             else
    2344       32438 :                 tupdesc = get_expr_result_tupdesc(rtfunc->funcexpr, true);
    2345       32546 :             if (tupdesc && tupdesc->tdtypeid != RECORDOID)
    2346             :             {
    2347             :                 /*
    2348             :                  * Named composite type, so individual columns could get
    2349             :                  * dropped.  Make a dependency on this specific column.
    2350             :                  */
    2351         222 :                 Oid         reltype = get_typ_typrelid(tupdesc->tdtypeid);
    2352             : 
    2353             :                 Assert(attnum - atts_done <= tupdesc->natts);
    2354         222 :                 if (OidIsValid(reltype))    /* can this fail? */
    2355         222 :                     add_object_address(RelationRelationId, reltype,
    2356             :                                        attnum - atts_done,
    2357             :                                        context->addrs);
    2358       32546 :                 return;
    2359             :             }
    2360             :             /* Nothing to do; function's result type is handled elsewhere */
    2361       32324 :             return;
    2362             :         }
    2363         222 :         atts_done += rtfunc->funccolcount;
    2364             :     }
    2365             : 
    2366             :     /* If we get here, must be looking for the ordinality column */
    2367          90 :     if (rte->funcordinality && attnum == atts_done + 1)
    2368          90 :         return;
    2369             : 
    2370             :     /* this probably can't happen ... */
    2371           0 :     ereport(ERROR,
    2372             :             (errcode(ERRCODE_UNDEFINED_COLUMN),
    2373             :              errmsg("column %d of relation \"%s\" does not exist",
    2374             :                     attnum, rte->eref->aliasname)));
    2375             : }
    2376             : 
    2377             : /*
    2378             :  * Given an array of dependency references, eliminate any duplicates.
    2379             :  */
    2380             : static void
    2381      332026 : eliminate_duplicate_dependencies(ObjectAddresses *addrs)
    2382             : {
    2383             :     ObjectAddress *priorobj;
    2384             :     int         oldref,
    2385             :                 newrefs;
    2386             : 
    2387             :     /*
    2388             :      * We can't sort if the array has "extra" data, because there's no way to
    2389             :      * keep it in sync.  Fortunately that combination of features is not
    2390             :      * needed.
    2391             :      */
    2392             :     Assert(!addrs->extras);
    2393             : 
    2394      332026 :     if (addrs->numrefs <= 1)
    2395       89958 :         return;                 /* nothing to do */
    2396             : 
    2397             :     /* Sort the refs so that duplicates are adjacent */
    2398      242068 :     qsort(addrs->refs, addrs->numrefs, sizeof(ObjectAddress),
    2399             :           object_address_comparator);
    2400             : 
    2401             :     /* Remove dups */
    2402      242068 :     priorobj = addrs->refs;
    2403      242068 :     newrefs = 1;
    2404     1586480 :     for (oldref = 1; oldref < addrs->numrefs; oldref++)
    2405             :     {
    2406     1344412 :         ObjectAddress *thisobj = addrs->refs + oldref;
    2407             : 
    2408     1344412 :         if (priorobj->classId == thisobj->classId &&
    2409     1151766 :             priorobj->objectId == thisobj->objectId)
    2410             :         {
    2411      597128 :             if (priorobj->objectSubId == thisobj->objectSubId)
    2412      459860 :                 continue;       /* identical, so drop thisobj */
    2413             : 
    2414             :             /*
    2415             :              * If we have a whole-object reference and a reference to a part
    2416             :              * of the same object, we don't need the whole-object reference
    2417             :              * (for example, we don't need to reference both table foo and
    2418             :              * column foo.bar).  The whole-object reference will always appear
    2419             :              * first in the sorted list.
    2420             :              */
    2421      137268 :             if (priorobj->objectSubId == 0)
    2422             :             {
    2423             :                 /* replace whole ref with partial */
    2424       30094 :                 priorobj->objectSubId = thisobj->objectSubId;
    2425       30094 :                 continue;
    2426             :             }
    2427             :         }
    2428             :         /* Not identical, so add thisobj to output set */
    2429      854458 :         priorobj++;
    2430      854458 :         *priorobj = *thisobj;
    2431      854458 :         newrefs++;
    2432             :     }
    2433             : 
    2434      242068 :     addrs->numrefs = newrefs;
    2435             : }
    2436             : 
    2437             : /*
    2438             :  * qsort comparator for ObjectAddress items
    2439             :  */
    2440             : static int
    2441     4567944 : object_address_comparator(const void *a, const void *b)
    2442             : {
    2443     4567944 :     const ObjectAddress *obja = (const ObjectAddress *) a;
    2444     4567944 :     const ObjectAddress *objb = (const ObjectAddress *) b;
    2445             : 
    2446             :     /*
    2447             :      * Primary sort key is OID descending.  Most of the time, this will result
    2448             :      * in putting newer objects before older ones, which is likely to be the
    2449             :      * right order to delete in.
    2450             :      */
    2451     4567944 :     if (obja->objectId > objb->objectId)
    2452     1065884 :         return -1;
    2453     3502060 :     if (obja->objectId < objb->objectId)
    2454     2465472 :         return 1;
    2455             : 
    2456             :     /*
    2457             :      * Next sort on catalog ID, in case identical OIDs appear in different
    2458             :      * catalogs.  Sort direction is pretty arbitrary here.
    2459             :      */
    2460     1036588 :     if (obja->classId < objb->classId)
    2461           0 :         return -1;
    2462     1036588 :     if (obja->classId > objb->classId)
    2463           0 :         return 1;
    2464             : 
    2465             :     /*
    2466             :      * Last, sort on object subId.
    2467             :      *
    2468             :      * We sort the subId as an unsigned int so that 0 (the whole object) will
    2469             :      * come first.  This is essential for eliminate_duplicate_dependencies,
    2470             :      * and is also the best order for findDependentObjects.
    2471             :      */
    2472     1036588 :     if ((unsigned int) obja->objectSubId < (unsigned int) objb->objectSubId)
    2473      249064 :         return -1;
    2474      787524 :     if ((unsigned int) obja->objectSubId > (unsigned int) objb->objectSubId)
    2475      221770 :         return 1;
    2476      565754 :     return 0;
    2477             : }
    2478             : 
    2479             : /*
    2480             :  * Routines for handling an expansible array of ObjectAddress items.
    2481             :  *
    2482             :  * new_object_addresses: create a new ObjectAddresses array.
    2483             :  */
    2484             : ObjectAddresses *
    2485      391096 : new_object_addresses(void)
    2486             : {
    2487             :     ObjectAddresses *addrs;
    2488             : 
    2489      391096 :     addrs = palloc(sizeof(ObjectAddresses));
    2490             : 
    2491      391096 :     addrs->numrefs = 0;
    2492      391096 :     addrs->maxrefs = 32;
    2493      391096 :     addrs->refs = (ObjectAddress *)
    2494      391096 :         palloc(addrs->maxrefs * sizeof(ObjectAddress));
    2495      391096 :     addrs->extras = NULL;        /* until/unless needed */
    2496             : 
    2497      391096 :     return addrs;
    2498             : }
    2499             : 
    2500             : /*
    2501             :  * Add an entry to an ObjectAddresses array.
    2502             :  */
    2503             : static void
    2504      638158 : add_object_address(Oid classId, Oid objectId, int32 subId,
    2505             :                    ObjectAddresses *addrs)
    2506             : {
    2507             :     ObjectAddress *item;
    2508             : 
    2509             :     /* enlarge array if needed */
    2510      638158 :     if (addrs->numrefs >= addrs->maxrefs)
    2511             :     {
    2512        8542 :         addrs->maxrefs *= 2;
    2513        8542 :         addrs->refs = (ObjectAddress *)
    2514        8542 :             repalloc(addrs->refs, addrs->maxrefs * sizeof(ObjectAddress));
    2515             :         Assert(!addrs->extras);
    2516             :     }
    2517             :     /* record this item */
    2518      638158 :     item = addrs->refs + addrs->numrefs;
    2519      638158 :     item->classId = classId;
    2520      638158 :     item->objectId = objectId;
    2521      638158 :     item->objectSubId = subId;
    2522      638158 :     addrs->numrefs++;
    2523      638158 : }
    2524             : 
    2525             : /*
    2526             :  * Add an entry to an ObjectAddresses array.
    2527             :  *
    2528             :  * As above, but specify entry exactly.
    2529             :  */
    2530             : void
    2531     1049272 : add_exact_object_address(const ObjectAddress *object,
    2532             :                          ObjectAddresses *addrs)
    2533             : {
    2534             :     ObjectAddress *item;
    2535             : 
    2536             :     /* enlarge array if needed */
    2537     1049272 :     if (addrs->numrefs >= addrs->maxrefs)
    2538             :     {
    2539          42 :         addrs->maxrefs *= 2;
    2540          42 :         addrs->refs = (ObjectAddress *)
    2541          42 :             repalloc(addrs->refs, addrs->maxrefs * sizeof(ObjectAddress));
    2542             :         Assert(!addrs->extras);
    2543             :     }
    2544             :     /* record this item */
    2545     1049272 :     item = addrs->refs + addrs->numrefs;
    2546     1049272 :     *item = *object;
    2547     1049272 :     addrs->numrefs++;
    2548     1049272 : }
    2549             : 
    2550             : /*
    2551             :  * Add an entry to an ObjectAddresses array.
    2552             :  *
    2553             :  * As above, but specify entry exactly and provide some "extra" data too.
    2554             :  */
    2555             : static void
    2556      178350 : add_exact_object_address_extra(const ObjectAddress *object,
    2557             :                                const ObjectAddressExtra *extra,
    2558             :                                ObjectAddresses *addrs)
    2559             : {
    2560             :     ObjectAddress *item;
    2561             :     ObjectAddressExtra *itemextra;
    2562             : 
    2563             :     /* allocate extra space if first time */
    2564      178350 :     if (!addrs->extras)
    2565       29336 :         addrs->extras = (ObjectAddressExtra *)
    2566       29336 :             palloc(addrs->maxrefs * sizeof(ObjectAddressExtra));
    2567             : 
    2568             :     /* enlarge array if needed */
    2569      178350 :     if (addrs->numrefs >= addrs->maxrefs)
    2570             :     {
    2571         622 :         addrs->maxrefs *= 2;
    2572         622 :         addrs->refs = (ObjectAddress *)
    2573         622 :             repalloc(addrs->refs, addrs->maxrefs * sizeof(ObjectAddress));
    2574         622 :         addrs->extras = (ObjectAddressExtra *)
    2575         622 :             repalloc(addrs->extras, addrs->maxrefs * sizeof(ObjectAddressExtra));
    2576             :     }
    2577             :     /* record this item */
    2578      178350 :     item = addrs->refs + addrs->numrefs;
    2579      178350 :     *item = *object;
    2580      178350 :     itemextra = addrs->extras + addrs->numrefs;
    2581      178350 :     *itemextra = *extra;
    2582      178350 :     addrs->numrefs++;
    2583      178350 : }
    2584             : 
    2585             : /*
    2586             :  * Test whether an object is present in an ObjectAddresses array.
    2587             :  *
    2588             :  * We return "true" if object is a subobject of something in the array, too.
    2589             :  */
    2590             : bool
    2591         576 : object_address_present(const ObjectAddress *object,
    2592             :                        const ObjectAddresses *addrs)
    2593             : {
    2594             :     int         i;
    2595             : 
    2596        1968 :     for (i = addrs->numrefs - 1; i >= 0; i--)
    2597             :     {
    2598        1392 :         const ObjectAddress *thisobj = addrs->refs + i;
    2599             : 
    2600        1392 :         if (object->classId == thisobj->classId &&
    2601         394 :             object->objectId == thisobj->objectId)
    2602             :         {
    2603           0 :             if (object->objectSubId == thisobj->objectSubId ||
    2604           0 :                 thisobj->objectSubId == 0)
    2605           0 :                 return true;
    2606             :         }
    2607             :     }
    2608             : 
    2609         576 :     return false;
    2610             : }
    2611             : 
    2612             : /*
    2613             :  * As above, except that if the object is present then also OR the given
    2614             :  * flags into its associated extra data (which must exist).
    2615             :  */
    2616             : static bool
    2617      221782 : object_address_present_add_flags(const ObjectAddress *object,
    2618             :                                  int flags,
    2619             :                                  ObjectAddresses *addrs)
    2620             : {
    2621      221782 :     bool        result = false;
    2622             :     int         i;
    2623             : 
    2624     5343532 :     for (i = addrs->numrefs - 1; i >= 0; i--)
    2625             :     {
    2626     5121750 :         ObjectAddress *thisobj = addrs->refs + i;
    2627             : 
    2628     5121750 :         if (object->classId == thisobj->classId &&
    2629     1703690 :             object->objectId == thisobj->objectId)
    2630             :         {
    2631       41966 :             if (object->objectSubId == thisobj->objectSubId)
    2632             :             {
    2633       41552 :                 ObjectAddressExtra *thisextra = addrs->extras + i;
    2634             : 
    2635       41552 :                 thisextra->flags |= flags;
    2636       41552 :                 result = true;
    2637             :             }
    2638         414 :             else if (thisobj->objectSubId == 0)
    2639             :             {
    2640             :                 /*
    2641             :                  * We get here if we find a need to delete a column after
    2642             :                  * having already decided to drop its whole table.  Obviously
    2643             :                  * we no longer need to drop the subobject, so report that we
    2644             :                  * found the subobject in the array.  But don't plaster its
    2645             :                  * flags on the whole object.
    2646             :                  */
    2647         396 :                 result = true;
    2648             :             }
    2649          18 :             else if (object->objectSubId == 0)
    2650             :             {
    2651             :                 /*
    2652             :                  * We get here if we find a need to delete a whole table after
    2653             :                  * having already decided to drop one of its columns.  We
    2654             :                  * can't report that the whole object is in the array, but we
    2655             :                  * should mark the subobject with the whole object's flags.
    2656             :                  *
    2657             :                  * It might seem attractive to physically delete the column's
    2658             :                  * array entry, or at least mark it as no longer needing
    2659             :                  * separate deletion.  But that could lead to, e.g., dropping
    2660             :                  * the column's datatype before we drop the table, which does
    2661             :                  * not seem like a good idea.  This is a very rare situation
    2662             :                  * in practice, so we just take the hit of doing a separate
    2663             :                  * DROP COLUMN action even though we know we're gonna delete
    2664             :                  * the table later.
    2665             :                  *
    2666             :                  * What we can do, though, is mark this as a subobject so that
    2667             :                  * we don't report it separately, which is confusing because
    2668             :                  * it's unpredictable whether it happens or not.  But do so
    2669             :                  * only if flags != 0 (flags == 0 is a read-only probe).
    2670             :                  *
    2671             :                  * Because there could be other subobjects of this object in
    2672             :                  * the array, this case means we always have to loop through
    2673             :                  * the whole array; we cannot exit early on a match.
    2674             :                  */
    2675           6 :                 ObjectAddressExtra *thisextra = addrs->extras + i;
    2676             : 
    2677           6 :                 if (flags)
    2678           6 :                     thisextra->flags |= (flags | DEPFLAG_SUBOBJECT);
    2679             :             }
    2680             :         }
    2681             :     }
    2682             : 
    2683      221782 :     return result;
    2684             : }
    2685             : 
    2686             : /*
    2687             :  * Similar to above, except we search an ObjectAddressStack.
    2688             :  */
    2689             : static bool
    2690      321140 : stack_address_present_add_flags(const ObjectAddress *object,
    2691             :                                 int flags,
    2692             :                                 ObjectAddressStack *stack)
    2693             : {
    2694      321140 :     bool        result = false;
    2695             :     ObjectAddressStack *stackptr;
    2696             : 
    2697      861974 :     for (stackptr = stack; stackptr; stackptr = stackptr->next)
    2698             :     {
    2699      540834 :         const ObjectAddress *thisobj = stackptr->object;
    2700             : 
    2701      540834 :         if (object->classId == thisobj->classId &&
    2702      250600 :             object->objectId == thisobj->objectId)
    2703             :         {
    2704       99394 :             if (object->objectSubId == thisobj->objectSubId)
    2705             :             {
    2706       98674 :                 stackptr->flags |= flags;
    2707       98674 :                 result = true;
    2708             :             }
    2709         720 :             else if (thisobj->objectSubId == 0)
    2710             :             {
    2711             :                 /*
    2712             :                  * We're visiting a column with whole table already on stack.
    2713             :                  * As in object_address_present_add_flags(), we can skip
    2714             :                  * further processing of the subobject, but we don't want to
    2715             :                  * propagate flags for the subobject to the whole object.
    2716             :                  */
    2717         684 :                 result = true;
    2718             :             }
    2719          36 :             else if (object->objectSubId == 0)
    2720             :             {
    2721             :                 /*
    2722             :                  * We're visiting a table with column already on stack.  As in
    2723             :                  * object_address_present_add_flags(), we should propagate
    2724             :                  * flags for the whole object to each of its subobjects.
    2725             :                  */
    2726           0 :                 if (flags)
    2727           0 :                     stackptr->flags |= (flags | DEPFLAG_SUBOBJECT);
    2728             :             }
    2729             :         }
    2730             :     }
    2731             : 
    2732      321140 :     return result;
    2733             : }
    2734             : 
    2735             : /*
    2736             :  * Record multiple dependencies from an ObjectAddresses array, after first
    2737             :  * removing any duplicates.
    2738             :  */
    2739             : void
    2740      299394 : record_object_address_dependencies(const ObjectAddress *depender,
    2741             :                                    ObjectAddresses *referenced,
    2742             :                                    DependencyType behavior)
    2743             : {
    2744      299394 :     eliminate_duplicate_dependencies(referenced);
    2745      299394 :     recordMultipleDependencies(depender,
    2746      299394 :                                referenced->refs, referenced->numrefs,
    2747             :                                behavior);
    2748      299394 : }
    2749             : 
    2750             : /*
    2751             :  * Sort the items in an ObjectAddresses array.
    2752             :  *
    2753             :  * The major sort key is OID-descending, so that newer objects will be listed
    2754             :  * first in most cases.  This is primarily useful for ensuring stable outputs
    2755             :  * from regression tests; it's not recommended if the order of the objects is
    2756             :  * determined by user input, such as the order of targets in a DROP command.
    2757             :  */
    2758             : void
    2759         134 : sort_object_addresses(ObjectAddresses *addrs)
    2760             : {
    2761         134 :     if (addrs->numrefs > 1)
    2762          76 :         qsort(addrs->refs, addrs->numrefs,
    2763             :               sizeof(ObjectAddress),
    2764             :               object_address_comparator);
    2765         134 : }
    2766             : 
    2767             : /*
    2768             :  * Clean up when done with an ObjectAddresses array.
    2769             :  */
    2770             : void
    2771      389138 : free_object_addresses(ObjectAddresses *addrs)
    2772             : {
    2773      389138 :     pfree(addrs->refs);
    2774      389138 :     if (addrs->extras)
    2775       29006 :         pfree(addrs->extras);
    2776      389138 :     pfree(addrs);
    2777      389138 : }
    2778             : 
    2779             : /*
    2780             :  * delete initial ACL for extension objects
    2781             :  */
    2782             : static void
    2783      173548 : DeleteInitPrivs(const ObjectAddress *object)
    2784             : {
    2785             :     Relation    relation;
    2786             :     ScanKeyData key[3];
    2787             :     SysScanDesc scan;
    2788             :     HeapTuple   oldtuple;
    2789             : 
    2790      173548 :     relation = table_open(InitPrivsRelationId, RowExclusiveLock);
    2791             : 
    2792      173548 :     ScanKeyInit(&key[0],
    2793             :                 Anum_pg_init_privs_objoid,
    2794             :                 BTEqualStrategyNumber, F_OIDEQ,
    2795             :                 ObjectIdGetDatum(object->objectId));
    2796      173548 :     ScanKeyInit(&key[1],
    2797             :                 Anum_pg_init_privs_classoid,
    2798             :                 BTEqualStrategyNumber, F_OIDEQ,
    2799             :                 ObjectIdGetDatum(object->classId));
    2800      173548 :     ScanKeyInit(&key[2],
    2801             :                 Anum_pg_init_privs_objsubid,
    2802             :                 BTEqualStrategyNumber, F_INT4EQ,
    2803             :                 Int32GetDatum(object->objectSubId));
    2804             : 
    2805      173548 :     scan = systable_beginscan(relation, InitPrivsObjIndexId, true,
    2806             :                               NULL, 3, key);
    2807             : 
    2808      173638 :     while (HeapTupleIsValid(oldtuple = systable_getnext(scan)))
    2809          90 :         CatalogTupleDelete(relation, &oldtuple->t_self);
    2810             : 
    2811      173548 :     systable_endscan(scan);
    2812             : 
    2813      173548 :     table_close(relation, RowExclusiveLock);
    2814      173548 : }

Generated by: LCOV version 1.14