PostgreSQL Source Code  git master
pg_shdepend.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * pg_shdepend.c
4  * routines to support manipulation of the pg_shdepend relation
5  *
6  * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  *
10  * IDENTIFICATION
11  * src/backend/catalog/pg_shdepend.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/indexing.h"
24 #include "catalog/pg_authid.h"
25 #include "catalog/pg_collation.h"
26 #include "catalog/pg_conversion.h"
27 #include "catalog/pg_database.h"
28 #include "catalog/pg_default_acl.h"
30 #include "catalog/pg_extension.h"
33 #include "catalog/pg_language.h"
34 #include "catalog/pg_largeobject.h"
36 #include "catalog/pg_namespace.h"
37 #include "catalog/pg_opclass.h"
38 #include "catalog/pg_operator.h"
39 #include "catalog/pg_opfamily.h"
40 #include "catalog/pg_proc.h"
41 #include "catalog/pg_shdepend.h"
44 #include "catalog/pg_tablespace.h"
45 #include "catalog/pg_ts_config.h"
46 #include "catalog/pg_ts_dict.h"
47 #include "catalog/pg_type.h"
49 #include "commands/alter.h"
50 #include "commands/collationcmds.h"
52 #include "commands/dbcommands.h"
53 #include "commands/defrem.h"
54 #include "commands/event_trigger.h"
55 #include "commands/extension.h"
56 #include "commands/policy.h"
57 #include "commands/proclang.h"
59 #include "commands/schemacmds.h"
61 #include "commands/tablecmds.h"
62 #include "commands/tablespace.h"
63 #include "commands/typecmds.h"
64 #include "miscadmin.h"
65 #include "storage/lmgr.h"
66 #include "utils/acl.h"
67 #include "utils/fmgroids.h"
68 #include "utils/memutils.h"
69 #include "utils/syscache.h"
70 
71 typedef enum
72 {
77 
78 typedef struct
79 {
81  char deptype;
84 
85 static void getOidListDiff(Oid *list1, int *nlist1, Oid *list2, int *nlist2);
86 static Oid classIdGetDbId(Oid classId);
87 static void shdepChangeDep(Relation sdepRel,
88  Oid classid, Oid objid, int32 objsubid,
89  Oid refclassid, Oid refobjid,
90  SharedDependencyType deptype);
91 static void shdepAddDependency(Relation sdepRel,
92  Oid classId, Oid objectId, int32 objsubId,
93  Oid refclassId, Oid refobjId,
94  SharedDependencyType deptype);
95 static void shdepDropDependency(Relation sdepRel,
96  Oid classId, Oid objectId, int32 objsubId,
97  bool drop_subobjects,
98  Oid refclassId, Oid refobjId,
99  SharedDependencyType deptype);
100 static void storeObjectDescription(StringInfo descs,
102  ObjectAddress *object,
103  SharedDependencyType deptype,
104  int count);
105 
106 
107 /*
108  * recordSharedDependencyOn
109  *
110  * Record a dependency between 2 objects via their respective ObjectAddresses.
111  * The first argument is the dependent object, the second the one it
112  * references (which must be a shared object).
113  *
114  * This locks the referenced object and makes sure it still exists.
115  * Then it creates an entry in pg_shdepend. The lock is kept until
116  * the end of the transaction.
117  *
118  * Dependencies on pinned objects are not recorded.
119  */
120 void
122  ObjectAddress *referenced,
123  SharedDependencyType deptype)
124 {
125  Relation sdepRel;
126 
127  /*
128  * Objects in pg_shdepend can't have SubIds.
129  */
130  Assert(depender->objectSubId == 0);
131  Assert(referenced->objectSubId == 0);
132 
133  /*
134  * During bootstrap, do nothing since pg_shdepend may not exist yet.
135  * initdb will fill in appropriate pg_shdepend entries after bootstrap.
136  */
138  return;
139 
140  sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);
141 
142  /* If the referenced object is pinned, do nothing. */
143  if (!IsPinnedObject(referenced->classId, referenced->objectId))
144  {
145  shdepAddDependency(sdepRel, depender->classId, depender->objectId,
146  depender->objectSubId,
147  referenced->classId, referenced->objectId,
148  deptype);
149  }
150 
151  table_close(sdepRel, RowExclusiveLock);
152 }
153 
154 /*
155  * recordDependencyOnOwner
156  *
157  * A convenient wrapper of recordSharedDependencyOn -- register the specified
158  * user as owner of the given object.
159  *
160  * Note: it's the caller's responsibility to ensure that there isn't an owner
161  * entry for the object already.
162  */
163 void
164 recordDependencyOnOwner(Oid classId, Oid objectId, Oid owner)
165 {
166  ObjectAddress myself,
167  referenced;
168 
169  myself.classId = classId;
170  myself.objectId = objectId;
171  myself.objectSubId = 0;
172 
173  referenced.classId = AuthIdRelationId;
174  referenced.objectId = owner;
175  referenced.objectSubId = 0;
176 
177  recordSharedDependencyOn(&myself, &referenced, SHARED_DEPENDENCY_OWNER);
178 }
179 
180 /*
181  * shdepChangeDep
182  *
183  * Update shared dependency records to account for an updated referenced
184  * object. This is an internal workhorse for operations such as changing
185  * an object's owner.
186  *
187  * There must be no more than one existing entry for the given dependent
188  * object and dependency type! So in practice this can only be used for
189  * updating SHARED_DEPENDENCY_OWNER and SHARED_DEPENDENCY_TABLESPACE
190  * entries, which should have that property.
191  *
192  * If there is no previous entry, we assume it was referencing a PINned
193  * object, so we create a new entry. If the new referenced object is
194  * PINned, we don't create an entry (and drop the old one, if any).
195  * (For tablespaces, we don't record dependencies in certain cases, so
196  * there are other possible reasons for entries to be missing.)
197  *
198  * sdepRel must be the pg_shdepend relation, already opened and suitably
199  * locked.
200  */
201 static void
203  Oid classid, Oid objid, int32 objsubid,
204  Oid refclassid, Oid refobjid,
205  SharedDependencyType deptype)
206 {
207  Oid dbid = classIdGetDbId(classid);
208  HeapTuple oldtup = NULL;
209  HeapTuple scantup;
210  ScanKeyData key[4];
211  SysScanDesc scan;
212 
213  /*
214  * Make sure the new referenced object doesn't go away while we record the
215  * dependency.
216  */
217  shdepLockAndCheckObject(refclassid, refobjid);
218 
219  /*
220  * Look for a previous entry
221  */
222  ScanKeyInit(&key[0],
223  Anum_pg_shdepend_dbid,
224  BTEqualStrategyNumber, F_OIDEQ,
225  ObjectIdGetDatum(dbid));
226  ScanKeyInit(&key[1],
227  Anum_pg_shdepend_classid,
228  BTEqualStrategyNumber, F_OIDEQ,
229  ObjectIdGetDatum(classid));
230  ScanKeyInit(&key[2],
231  Anum_pg_shdepend_objid,
232  BTEqualStrategyNumber, F_OIDEQ,
233  ObjectIdGetDatum(objid));
234  ScanKeyInit(&key[3],
235  Anum_pg_shdepend_objsubid,
236  BTEqualStrategyNumber, F_INT4EQ,
237  Int32GetDatum(objsubid));
238 
239  scan = systable_beginscan(sdepRel, SharedDependDependerIndexId, true,
240  NULL, 4, key);
241 
242  while ((scantup = systable_getnext(scan)) != NULL)
243  {
244  /* Ignore if not of the target dependency type */
245  if (((Form_pg_shdepend) GETSTRUCT(scantup))->deptype != deptype)
246  continue;
247  /* Caller screwed up if multiple matches */
248  if (oldtup)
249  elog(ERROR,
250  "multiple pg_shdepend entries for object %u/%u/%d deptype %c",
251  classid, objid, objsubid, deptype);
252  oldtup = heap_copytuple(scantup);
253  }
254 
255  systable_endscan(scan);
256 
257  if (IsPinnedObject(refclassid, refobjid))
258  {
259  /* No new entry needed, so just delete existing entry if any */
260  if (oldtup)
261  CatalogTupleDelete(sdepRel, &oldtup->t_self);
262  }
263  else if (oldtup)
264  {
265  /* Need to update existing entry */
266  Form_pg_shdepend shForm = (Form_pg_shdepend) GETSTRUCT(oldtup);
267 
268  /* Since oldtup is a copy, we can just modify it in-memory */
269  shForm->refclassid = refclassid;
270  shForm->refobjid = refobjid;
271 
272  CatalogTupleUpdate(sdepRel, &oldtup->t_self, oldtup);
273  }
274  else
275  {
276  /* Need to insert new entry */
277  Datum values[Natts_pg_shdepend];
278  bool nulls[Natts_pg_shdepend];
279 
280  memset(nulls, false, sizeof(nulls));
281 
282  values[Anum_pg_shdepend_dbid - 1] = ObjectIdGetDatum(dbid);
283  values[Anum_pg_shdepend_classid - 1] = ObjectIdGetDatum(classid);
284  values[Anum_pg_shdepend_objid - 1] = ObjectIdGetDatum(objid);
285  values[Anum_pg_shdepend_objsubid - 1] = Int32GetDatum(objsubid);
286 
287  values[Anum_pg_shdepend_refclassid - 1] = ObjectIdGetDatum(refclassid);
288  values[Anum_pg_shdepend_refobjid - 1] = ObjectIdGetDatum(refobjid);
289  values[Anum_pg_shdepend_deptype - 1] = CharGetDatum(deptype);
290 
291  /*
292  * we are reusing oldtup just to avoid declaring a new variable, but
293  * it's certainly a new tuple
294  */
295  oldtup = heap_form_tuple(RelationGetDescr(sdepRel), values, nulls);
296  CatalogTupleInsert(sdepRel, oldtup);
297  }
298 
299  if (oldtup)
300  heap_freetuple(oldtup);
301 }
302 
303 /*
304  * changeDependencyOnOwner
305  *
306  * Update the shared dependencies to account for the new owner.
307  *
308  * Note: we don't need an objsubid argument because only whole objects
309  * have owners.
310  */
311 void
312 changeDependencyOnOwner(Oid classId, Oid objectId, Oid newOwnerId)
313 {
314  Relation sdepRel;
315 
316  sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);
317 
318  /* Adjust the SHARED_DEPENDENCY_OWNER entry */
319  shdepChangeDep(sdepRel,
320  classId, objectId, 0,
321  AuthIdRelationId, newOwnerId,
323 
324  /*----------
325  * There should never be a SHARED_DEPENDENCY_ACL entry for the owner,
326  * so get rid of it if there is one. This can happen if the new owner
327  * was previously granted some rights to the object.
328  *
329  * This step is analogous to aclnewowner's removal of duplicate entries
330  * in the ACL. We have to do it to handle this scenario:
331  * A grants some rights on an object to B
332  * ALTER OWNER changes the object's owner to B
333  * ALTER OWNER changes the object's owner to C
334  * The third step would remove all mention of B from the object's ACL,
335  * but we'd still have a SHARED_DEPENDENCY_ACL for B if we did not do
336  * things this way.
337  *
338  * The rule against having a SHARED_DEPENDENCY_ACL entry for the owner
339  * allows us to fix things up in just this one place, without having
340  * to make the various ALTER OWNER routines each know about it.
341  *----------
342  */
343  shdepDropDependency(sdepRel, classId, objectId, 0, true,
344  AuthIdRelationId, newOwnerId,
346 
347  table_close(sdepRel, RowExclusiveLock);
348 }
349 
350 /*
351  * recordDependencyOnTablespace
352  *
353  * A convenient wrapper of recordSharedDependencyOn -- register the specified
354  * tablespace as default for the given object.
355  *
356  * Note: it's the caller's responsibility to ensure that there isn't a
357  * tablespace entry for the object already.
358  */
359 void
361 {
362  ObjectAddress myself,
363  referenced;
364 
365  ObjectAddressSet(myself, classId, objectId);
366  ObjectAddressSet(referenced, TableSpaceRelationId, tablespace);
367 
368  recordSharedDependencyOn(&myself, &referenced,
370 }
371 
372 /*
373  * changeDependencyOnTablespace
374  *
375  * Update the shared dependencies to account for the new tablespace.
376  *
377  * Note: we don't need an objsubid argument because only whole objects
378  * have tablespaces.
379  */
380 void
381 changeDependencyOnTablespace(Oid classId, Oid objectId, Oid newTablespaceId)
382 {
383  Relation sdepRel;
384 
385  sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);
386 
387  if (newTablespaceId != DEFAULTTABLESPACE_OID &&
388  newTablespaceId != InvalidOid)
389  shdepChangeDep(sdepRel,
390  classId, objectId, 0,
391  TableSpaceRelationId, newTablespaceId,
393  else
394  shdepDropDependency(sdepRel,
395  classId, objectId, 0, true,
398 
399  table_close(sdepRel, RowExclusiveLock);
400 }
401 
402 /*
403  * getOidListDiff
404  * Helper for updateAclDependencies.
405  *
406  * Takes two Oid arrays and removes elements that are common to both arrays,
407  * leaving just those that are in one input but not the other.
408  * We assume both arrays have been sorted and de-duped.
409  */
410 static void
411 getOidListDiff(Oid *list1, int *nlist1, Oid *list2, int *nlist2)
412 {
413  int in1,
414  in2,
415  out1,
416  out2;
417 
418  in1 = in2 = out1 = out2 = 0;
419  while (in1 < *nlist1 && in2 < *nlist2)
420  {
421  if (list1[in1] == list2[in2])
422  {
423  /* skip over duplicates */
424  in1++;
425  in2++;
426  }
427  else if (list1[in1] < list2[in2])
428  {
429  /* list1[in1] is not in list2 */
430  list1[out1++] = list1[in1++];
431  }
432  else
433  {
434  /* list2[in2] is not in list1 */
435  list2[out2++] = list2[in2++];
436  }
437  }
438 
439  /* any remaining list1 entries are not in list2 */
440  while (in1 < *nlist1)
441  {
442  list1[out1++] = list1[in1++];
443  }
444 
445  /* any remaining list2 entries are not in list1 */
446  while (in2 < *nlist2)
447  {
448  list2[out2++] = list2[in2++];
449  }
450 
451  *nlist1 = out1;
452  *nlist2 = out2;
453 }
454 
455 /*
456  * updateAclDependencies
457  * Update the pg_shdepend info for an object's ACL during GRANT/REVOKE.
458  *
459  * classId, objectId, objsubId: identify the object whose ACL this is
460  * ownerId: role owning the object
461  * noldmembers, oldmembers: array of roleids appearing in old ACL
462  * nnewmembers, newmembers: array of roleids appearing in new ACL
463  *
464  * We calculate the differences between the new and old lists of roles,
465  * and then insert or delete from pg_shdepend as appropriate.
466  *
467  * Note that we can't just insert all referenced roles blindly during GRANT,
468  * because we would end up with duplicate registered dependencies. We could
469  * check for existence of the tuples before inserting, but that seems to be
470  * more expensive than what we are doing here. Likewise we can't just delete
471  * blindly during REVOKE, because the user may still have other privileges.
472  * It is also possible that REVOKE actually adds dependencies, due to
473  * instantiation of a formerly implicit default ACL (although at present,
474  * all such dependencies should be for the owning role, which we ignore here).
475  *
476  * NOTE: Both input arrays must be sorted and de-duped. (Typically they
477  * are extracted from an ACL array by aclmembers(), which takes care of
478  * both requirements.) The arrays are pfreed before return.
479  */
480 void
481 updateAclDependencies(Oid classId, Oid objectId, int32 objsubId,
482  Oid ownerId,
483  int noldmembers, Oid *oldmembers,
484  int nnewmembers, Oid *newmembers)
485 {
486  Relation sdepRel;
487  int i;
488 
489  /*
490  * Remove entries that are common to both lists; those represent existing
491  * dependencies we don't need to change.
492  *
493  * OK to overwrite the inputs since we'll pfree them anyway.
494  */
495  getOidListDiff(oldmembers, &noldmembers, newmembers, &nnewmembers);
496 
497  if (noldmembers > 0 || nnewmembers > 0)
498  {
499  sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);
500 
501  /* Add new dependencies that weren't already present */
502  for (i = 0; i < nnewmembers; i++)
503  {
504  Oid roleid = newmembers[i];
505 
506  /*
507  * Skip the owner: he has an OWNER shdep entry instead. (This is
508  * not just a space optimization; it makes ALTER OWNER easier. See
509  * notes in changeDependencyOnOwner.)
510  */
511  if (roleid == ownerId)
512  continue;
513 
514  /* Skip pinned roles; they don't need dependency entries */
515  if (IsPinnedObject(AuthIdRelationId, roleid))
516  continue;
517 
518  shdepAddDependency(sdepRel, classId, objectId, objsubId,
519  AuthIdRelationId, roleid,
521  }
522 
523  /* Drop no-longer-used old dependencies */
524  for (i = 0; i < noldmembers; i++)
525  {
526  Oid roleid = oldmembers[i];
527 
528  /* Skip the owner, same as above */
529  if (roleid == ownerId)
530  continue;
531 
532  /* Skip pinned roles */
533  if (IsPinnedObject(AuthIdRelationId, roleid))
534  continue;
535 
536  shdepDropDependency(sdepRel, classId, objectId, objsubId,
537  false, /* exact match on objsubId */
538  AuthIdRelationId, roleid,
540  }
541 
542  table_close(sdepRel, RowExclusiveLock);
543  }
544 
545  if (oldmembers)
546  pfree(oldmembers);
547  if (newmembers)
548  pfree(newmembers);
549 }
550 
551 /*
552  * A struct to keep track of dependencies found in other databases.
553  */
554 typedef struct
555 {
557  int count;
558 } remoteDep;
559 
560 /*
561  * qsort comparator for ShDependObjectInfo items
562  */
563 static int
564 shared_dependency_comparator(const void *a, const void *b)
565 {
566  const ShDependObjectInfo *obja = (const ShDependObjectInfo *) a;
567  const ShDependObjectInfo *objb = (const ShDependObjectInfo *) b;
568 
569  /*
570  * Primary sort key is OID ascending.
571  */
572  if (obja->object.objectId < objb->object.objectId)
573  return -1;
574  if (obja->object.objectId > objb->object.objectId)
575  return 1;
576 
577  /*
578  * Next sort on catalog ID, in case identical OIDs appear in different
579  * catalogs. Sort direction is pretty arbitrary here.
580  */
581  if (obja->object.classId < objb->object.classId)
582  return -1;
583  if (obja->object.classId > objb->object.classId)
584  return 1;
585 
586  /*
587  * Sort on object subId.
588  *
589  * We sort the subId as an unsigned int so that 0 (the whole object) will
590  * come first.
591  */
592  if ((unsigned int) obja->object.objectSubId < (unsigned int) objb->object.objectSubId)
593  return -1;
594  if ((unsigned int) obja->object.objectSubId > (unsigned int) objb->object.objectSubId)
595  return 1;
596 
597  /*
598  * Last, sort on deptype, in case the same object has multiple dependency
599  * types. (Note that there's no need to consider objtype, as that's
600  * determined by the catalog OID.)
601  */
602  if (obja->deptype < objb->deptype)
603  return -1;
604  if (obja->deptype > objb->deptype)
605  return 1;
606 
607  return 0;
608 }
609 
610 /*
611  * checkSharedDependencies
612  *
613  * Check whether there are shared dependency entries for a given shared
614  * object; return true if so.
615  *
616  * In addition, return a string containing a newline-separated list of object
617  * descriptions that depend on the shared object, or NULL if none is found.
618  * We actually return two such strings; the "detail" result is suitable for
619  * returning to the client as an errdetail() string, and is limited in size.
620  * The "detail_log" string is potentially much longer, and should be emitted
621  * to the server log only.
622  *
623  * We can find three different kinds of dependencies: dependencies on objects
624  * of the current database; dependencies on shared objects; and dependencies
625  * on objects local to other databases. We can (and do) provide descriptions
626  * of the two former kinds of objects, but we can't do that for "remote"
627  * objects, so we just provide a count of them.
628  */
629 bool
630 checkSharedDependencies(Oid classId, Oid objectId,
631  char **detail_msg, char **detail_log_msg)
632 {
633  Relation sdepRel;
634  ScanKeyData key[2];
635  SysScanDesc scan;
636  HeapTuple tup;
637  int numReportedDeps = 0;
638  int numNotReportedDeps = 0;
639  int numNotReportedDbs = 0;
640  List *remDeps = NIL;
641  ListCell *cell;
642  ObjectAddress object;
643  ShDependObjectInfo *objects;
644  int numobjects;
645  int allocedobjects;
646  StringInfoData descs;
647  StringInfoData alldescs;
648 
649  /* This case can be dispatched quickly */
650  if (IsPinnedObject(classId, objectId))
651  {
652  object.classId = classId;
653  object.objectId = objectId;
654  object.objectSubId = 0;
655  ereport(ERROR,
656  (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
657  errmsg("cannot drop %s because it is required by the database system",
658  getObjectDescription(&object, false))));
659  }
660 
661  /*
662  * We limit the number of dependencies reported to the client to
663  * MAX_REPORTED_DEPS, since client software may not deal well with
664  * enormous error strings. The server log always gets a full report.
665  *
666  * For stability of regression test results, we sort local and shared
667  * objects by OID before reporting them. We don't worry about the order
668  * in which other databases are reported, though.
669  */
670 #define MAX_REPORTED_DEPS 100
671 
672  allocedobjects = 128; /* arbitrary initial array size */
673  objects = (ShDependObjectInfo *)
674  palloc(allocedobjects * sizeof(ShDependObjectInfo));
675  numobjects = 0;
676  initStringInfo(&descs);
677  initStringInfo(&alldescs);
678 
679  sdepRel = table_open(SharedDependRelationId, AccessShareLock);
680 
681  ScanKeyInit(&key[0],
682  Anum_pg_shdepend_refclassid,
683  BTEqualStrategyNumber, F_OIDEQ,
684  ObjectIdGetDatum(classId));
685  ScanKeyInit(&key[1],
686  Anum_pg_shdepend_refobjid,
687  BTEqualStrategyNumber, F_OIDEQ,
688  ObjectIdGetDatum(objectId));
689 
690  scan = systable_beginscan(sdepRel, SharedDependReferenceIndexId, true,
691  NULL, 2, key);
692 
693  while (HeapTupleIsValid(tup = systable_getnext(scan)))
694  {
695  Form_pg_shdepend sdepForm = (Form_pg_shdepend) GETSTRUCT(tup);
696 
697  object.classId = sdepForm->classid;
698  object.objectId = sdepForm->objid;
699  object.objectSubId = sdepForm->objsubid;
700 
701  /*
702  * If it's a dependency local to this database or it's a shared
703  * object, add it to the objects array.
704  *
705  * If it's a remote dependency, keep track of it so we can report the
706  * number of them later.
707  */
708  if (sdepForm->dbid == MyDatabaseId ||
709  sdepForm->dbid == InvalidOid)
710  {
711  if (numobjects >= allocedobjects)
712  {
713  allocedobjects *= 2;
714  objects = (ShDependObjectInfo *)
715  repalloc(objects,
716  allocedobjects * sizeof(ShDependObjectInfo));
717  }
718  objects[numobjects].object = object;
719  objects[numobjects].deptype = sdepForm->deptype;
720  objects[numobjects].objtype = (sdepForm->dbid == MyDatabaseId) ?
722  numobjects++;
723  }
724  else
725  {
726  /* It's not local nor shared, so it must be remote. */
727  remoteDep *dep;
728  bool stored = false;
729 
730  /*
731  * XXX this info is kept on a simple List. Maybe it's not good
732  * for performance, but using a hash table seems needlessly
733  * complex. The expected number of databases is not high anyway,
734  * I suppose.
735  */
736  foreach(cell, remDeps)
737  {
738  dep = lfirst(cell);
739  if (dep->dbOid == sdepForm->dbid)
740  {
741  dep->count++;
742  stored = true;
743  break;
744  }
745  }
746  if (!stored)
747  {
748  dep = (remoteDep *) palloc(sizeof(remoteDep));
749  dep->dbOid = sdepForm->dbid;
750  dep->count = 1;
751  remDeps = lappend(remDeps, dep);
752  }
753  }
754  }
755 
756  systable_endscan(scan);
757 
758  table_close(sdepRel, AccessShareLock);
759 
760  /*
761  * Sort and report local and shared objects.
762  */
763  if (numobjects > 1)
764  qsort((void *) objects, numobjects,
766 
767  for (int i = 0; i < numobjects; i++)
768  {
769  if (numReportedDeps < MAX_REPORTED_DEPS)
770  {
771  numReportedDeps++;
772  storeObjectDescription(&descs,
773  objects[i].objtype,
774  &objects[i].object,
775  objects[i].deptype,
776  0);
777  }
778  else
779  numNotReportedDeps++;
780  storeObjectDescription(&alldescs,
781  objects[i].objtype,
782  &objects[i].object,
783  objects[i].deptype,
784  0);
785  }
786 
787  /*
788  * Summarize dependencies in remote databases.
789  */
790  foreach(cell, remDeps)
791  {
792  remoteDep *dep = lfirst(cell);
793 
794  object.classId = DatabaseRelationId;
795  object.objectId = dep->dbOid;
796  object.objectSubId = 0;
797 
798  if (numReportedDeps < MAX_REPORTED_DEPS)
799  {
800  numReportedDeps++;
801  storeObjectDescription(&descs, REMOTE_OBJECT, &object,
803  }
804  else
805  numNotReportedDbs++;
806  storeObjectDescription(&alldescs, REMOTE_OBJECT, &object,
808  }
809 
810  pfree(objects);
811  list_free_deep(remDeps);
812 
813  if (descs.len == 0)
814  {
815  pfree(descs.data);
816  pfree(alldescs.data);
817  *detail_msg = *detail_log_msg = NULL;
818  return false;
819  }
820 
821  if (numNotReportedDeps > 0)
822  appendStringInfo(&descs, ngettext("\nand %d other object "
823  "(see server log for list)",
824  "\nand %d other objects "
825  "(see server log for list)",
826  numNotReportedDeps),
827  numNotReportedDeps);
828  if (numNotReportedDbs > 0)
829  appendStringInfo(&descs, ngettext("\nand objects in %d other database "
830  "(see server log for list)",
831  "\nand objects in %d other databases "
832  "(see server log for list)",
833  numNotReportedDbs),
834  numNotReportedDbs);
835 
836  *detail_msg = descs.data;
837  *detail_log_msg = alldescs.data;
838  return true;
839 }
840 
841 
842 /*
843  * copyTemplateDependencies
844  *
845  * Routine to create the initial shared dependencies of a new database.
846  * We simply copy the dependencies from the template database.
847  */
848 void
849 copyTemplateDependencies(Oid templateDbId, Oid newDbId)
850 {
851  Relation sdepRel;
852  TupleDesc sdepDesc;
853  ScanKeyData key[1];
854  SysScanDesc scan;
855  HeapTuple tup;
856  CatalogIndexState indstate;
857  TupleTableSlot **slot;
858  int max_slots,
859  slot_init_count,
860  slot_stored_count;
861 
862  sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);
863  sdepDesc = RelationGetDescr(sdepRel);
864 
865  /*
866  * Allocate the slots to use, but delay costly initialization until we
867  * know that they will be used.
868  */
870  slot = palloc(sizeof(TupleTableSlot *) * max_slots);
871 
872  indstate = CatalogOpenIndexes(sdepRel);
873 
874  /* Scan all entries with dbid = templateDbId */
875  ScanKeyInit(&key[0],
876  Anum_pg_shdepend_dbid,
877  BTEqualStrategyNumber, F_OIDEQ,
878  ObjectIdGetDatum(templateDbId));
879 
880  scan = systable_beginscan(sdepRel, SharedDependDependerIndexId, true,
881  NULL, 1, key);
882 
883  /* number of slots currently storing tuples */
884  slot_stored_count = 0;
885  /* number of slots currently initialized */
886  slot_init_count = 0;
887 
888  /*
889  * Copy the entries of the original database, changing the database Id to
890  * that of the new database. Note that because we are not copying rows
891  * with dbId == 0 (ie, rows describing dependent shared objects) we won't
892  * copy the ownership dependency of the template database itself; this is
893  * what we want.
894  */
895  while (HeapTupleIsValid(tup = systable_getnext(scan)))
896  {
897  Form_pg_shdepend shdep;
898 
899  if (slot_init_count < max_slots)
900  {
901  slot[slot_stored_count] = MakeSingleTupleTableSlot(sdepDesc, &TTSOpsHeapTuple);
902  slot_init_count++;
903  }
904 
905  ExecClearTuple(slot[slot_stored_count]);
906 
907  memset(slot[slot_stored_count]->tts_isnull, false,
908  slot[slot_stored_count]->tts_tupleDescriptor->natts * sizeof(bool));
909 
910  shdep = (Form_pg_shdepend) GETSTRUCT(tup);
911 
912  slot[slot_stored_count]->tts_values[Anum_pg_shdepend_dbid - 1] = ObjectIdGetDatum(newDbId);
913  slot[slot_stored_count]->tts_values[Anum_pg_shdepend_classid - 1] = shdep->classid;
914  slot[slot_stored_count]->tts_values[Anum_pg_shdepend_objid - 1] = shdep->objid;
915  slot[slot_stored_count]->tts_values[Anum_pg_shdepend_objsubid - 1] = shdep->objsubid;
916  slot[slot_stored_count]->tts_values[Anum_pg_shdepend_refclassid - 1] = shdep->refclassid;
917  slot[slot_stored_count]->tts_values[Anum_pg_shdepend_refobjid - 1] = shdep->refobjid;
918  slot[slot_stored_count]->tts_values[Anum_pg_shdepend_deptype - 1] = shdep->deptype;
919 
920  ExecStoreVirtualTuple(slot[slot_stored_count]);
921  slot_stored_count++;
922 
923  /* If slots are full, insert a batch of tuples */
924  if (slot_stored_count == max_slots)
925  {
926  CatalogTuplesMultiInsertWithInfo(sdepRel, slot, slot_stored_count, indstate);
927  slot_stored_count = 0;
928  }
929  }
930 
931  /* Insert any tuples left in the buffer */
932  if (slot_stored_count > 0)
933  CatalogTuplesMultiInsertWithInfo(sdepRel, slot, slot_stored_count, indstate);
934 
935  systable_endscan(scan);
936 
937  CatalogCloseIndexes(indstate);
938  table_close(sdepRel, RowExclusiveLock);
939 
940  /* Drop only the number of slots used */
941  for (int i = 0; i < slot_init_count; i++)
943  pfree(slot);
944 }
945 
946 /*
947  * dropDatabaseDependencies
948  *
949  * Delete pg_shdepend entries corresponding to a database that's being
950  * dropped.
951  */
952 void
954 {
955  Relation sdepRel;
956  ScanKeyData key[1];
957  SysScanDesc scan;
958  HeapTuple tup;
959 
960  sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);
961 
962  /*
963  * First, delete all the entries that have the database Oid in the dbid
964  * field.
965  */
966  ScanKeyInit(&key[0],
967  Anum_pg_shdepend_dbid,
968  BTEqualStrategyNumber, F_OIDEQ,
969  ObjectIdGetDatum(databaseId));
970  /* We leave the other index fields unspecified */
971 
972  scan = systable_beginscan(sdepRel, SharedDependDependerIndexId, true,
973  NULL, 1, key);
974 
975  while (HeapTupleIsValid(tup = systable_getnext(scan)))
976  {
977  CatalogTupleDelete(sdepRel, &tup->t_self);
978  }
979 
980  systable_endscan(scan);
981 
982  /* Now delete all entries corresponding to the database itself */
983  shdepDropDependency(sdepRel, DatabaseRelationId, databaseId, 0, true,
986 
987  table_close(sdepRel, RowExclusiveLock);
988 }
989 
990 /*
991  * deleteSharedDependencyRecordsFor
992  *
993  * Delete all pg_shdepend entries corresponding to an object that's being
994  * dropped or modified. The object is assumed to be either a shared object
995  * or local to the current database (the classId tells us which).
996  *
997  * If objectSubId is zero, we are deleting a whole object, so get rid of
998  * pg_shdepend entries for subobjects as well.
999  */
1000 void
1001 deleteSharedDependencyRecordsFor(Oid classId, Oid objectId, int32 objectSubId)
1002 {
1003  Relation sdepRel;
1004 
1005  sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);
1006 
1007  shdepDropDependency(sdepRel, classId, objectId, objectSubId,
1008  (objectSubId == 0),
1011 
1012  table_close(sdepRel, RowExclusiveLock);
1013 }
1014 
1015 /*
1016  * shdepAddDependency
1017  * Internal workhorse for inserting into pg_shdepend
1018  *
1019  * sdepRel must be the pg_shdepend relation, already opened and suitably
1020  * locked.
1021  */
1022 static void
1024  Oid classId, Oid objectId, int32 objsubId,
1025  Oid refclassId, Oid refobjId,
1026  SharedDependencyType deptype)
1027 {
1028  HeapTuple tup;
1029  Datum values[Natts_pg_shdepend];
1030  bool nulls[Natts_pg_shdepend];
1031 
1032  /*
1033  * Make sure the object doesn't go away while we record the dependency on
1034  * it. DROP routines should lock the object exclusively before they check
1035  * shared dependencies.
1036  */
1037  shdepLockAndCheckObject(refclassId, refobjId);
1038 
1039  memset(nulls, false, sizeof(nulls));
1040 
1041  /*
1042  * Form the new tuple and record the dependency.
1043  */
1044  values[Anum_pg_shdepend_dbid - 1] = ObjectIdGetDatum(classIdGetDbId(classId));
1045  values[Anum_pg_shdepend_classid - 1] = ObjectIdGetDatum(classId);
1046  values[Anum_pg_shdepend_objid - 1] = ObjectIdGetDatum(objectId);
1047  values[Anum_pg_shdepend_objsubid - 1] = Int32GetDatum(objsubId);
1048 
1049  values[Anum_pg_shdepend_refclassid - 1] = ObjectIdGetDatum(refclassId);
1050  values[Anum_pg_shdepend_refobjid - 1] = ObjectIdGetDatum(refobjId);
1051  values[Anum_pg_shdepend_deptype - 1] = CharGetDatum(deptype);
1052 
1053  tup = heap_form_tuple(sdepRel->rd_att, values, nulls);
1054 
1055  CatalogTupleInsert(sdepRel, tup);
1056 
1057  /* clean up */
1058  heap_freetuple(tup);
1059 }
1060 
1061 /*
1062  * shdepDropDependency
1063  * Internal workhorse for deleting entries from pg_shdepend.
1064  *
1065  * We drop entries having the following properties:
1066  * dependent object is the one identified by classId/objectId/objsubId
1067  * if refclassId isn't InvalidOid, it must match the entry's refclassid
1068  * if refobjId isn't InvalidOid, it must match the entry's refobjid
1069  * if deptype isn't SHARED_DEPENDENCY_INVALID, it must match entry's deptype
1070  *
1071  * If drop_subobjects is true, we ignore objsubId and consider all entries
1072  * matching classId/objectId.
1073  *
1074  * sdepRel must be the pg_shdepend relation, already opened and suitably
1075  * locked.
1076  */
1077 static void
1079  Oid classId, Oid objectId, int32 objsubId,
1080  bool drop_subobjects,
1081  Oid refclassId, Oid refobjId,
1082  SharedDependencyType deptype)
1083 {
1084  ScanKeyData key[4];
1085  int nkeys;
1086  SysScanDesc scan;
1087  HeapTuple tup;
1088 
1089  /* Scan for entries matching the dependent object */
1090  ScanKeyInit(&key[0],
1091  Anum_pg_shdepend_dbid,
1092  BTEqualStrategyNumber, F_OIDEQ,
1093  ObjectIdGetDatum(classIdGetDbId(classId)));
1094  ScanKeyInit(&key[1],
1095  Anum_pg_shdepend_classid,
1096  BTEqualStrategyNumber, F_OIDEQ,
1097  ObjectIdGetDatum(classId));
1098  ScanKeyInit(&key[2],
1099  Anum_pg_shdepend_objid,
1100  BTEqualStrategyNumber, F_OIDEQ,
1101  ObjectIdGetDatum(objectId));
1102  if (drop_subobjects)
1103  nkeys = 3;
1104  else
1105  {
1106  ScanKeyInit(&key[3],
1107  Anum_pg_shdepend_objsubid,
1108  BTEqualStrategyNumber, F_INT4EQ,
1109  Int32GetDatum(objsubId));
1110  nkeys = 4;
1111  }
1112 
1113  scan = systable_beginscan(sdepRel, SharedDependDependerIndexId, true,
1114  NULL, nkeys, key);
1115 
1116  while (HeapTupleIsValid(tup = systable_getnext(scan)))
1117  {
1118  Form_pg_shdepend shdepForm = (Form_pg_shdepend) GETSTRUCT(tup);
1119 
1120  /* Filter entries according to additional parameters */
1121  if (OidIsValid(refclassId) && shdepForm->refclassid != refclassId)
1122  continue;
1123  if (OidIsValid(refobjId) && shdepForm->refobjid != refobjId)
1124  continue;
1125  if (deptype != SHARED_DEPENDENCY_INVALID &&
1126  shdepForm->deptype != deptype)
1127  continue;
1128 
1129  /* OK, delete it */
1130  CatalogTupleDelete(sdepRel, &tup->t_self);
1131  }
1132 
1133  systable_endscan(scan);
1134 }
1135 
1136 /*
1137  * classIdGetDbId
1138  *
1139  * Get the database Id that should be used in pg_shdepend, given the OID
1140  * of the catalog containing the object. For shared objects, it's 0
1141  * (InvalidOid); for all other objects, it's the current database Id.
1142  */
1143 static Oid
1145 {
1146  Oid dbId;
1147 
1148  if (IsSharedRelation(classId))
1149  dbId = InvalidOid;
1150  else
1151  dbId = MyDatabaseId;
1152 
1153  return dbId;
1154 }
1155 
1156 /*
1157  * shdepLockAndCheckObject
1158  *
1159  * Lock the object that we are about to record a dependency on.
1160  * After it's locked, verify that it hasn't been dropped while we
1161  * weren't looking. If the object has been dropped, this function
1162  * does not return!
1163  */
1164 void
1165 shdepLockAndCheckObject(Oid classId, Oid objectId)
1166 {
1167  /* AccessShareLock should be OK, since we are not modifying the object */
1168  LockSharedObject(classId, objectId, 0, AccessShareLock);
1169 
1170  switch (classId)
1171  {
1172  case AuthIdRelationId:
1174  ereport(ERROR,
1175  (errcode(ERRCODE_UNDEFINED_OBJECT),
1176  errmsg("role %u was concurrently dropped",
1177  objectId)));
1178  break;
1179 
1180  case TableSpaceRelationId:
1181  {
1182  /* For lack of a syscache on pg_tablespace, do this: */
1183  char *tablespace = get_tablespace_name(objectId);
1184 
1185  if (tablespace == NULL)
1186  ereport(ERROR,
1187  (errcode(ERRCODE_UNDEFINED_OBJECT),
1188  errmsg("tablespace %u was concurrently dropped",
1189  objectId)));
1190  pfree(tablespace);
1191  break;
1192  }
1193 
1194  case DatabaseRelationId:
1195  {
1196  /* For lack of a syscache on pg_database, do this: */
1197  char *database = get_database_name(objectId);
1198 
1199  if (database == NULL)
1200  ereport(ERROR,
1201  (errcode(ERRCODE_UNDEFINED_OBJECT),
1202  errmsg("database %u was concurrently dropped",
1203  objectId)));
1204  pfree(database);
1205  break;
1206  }
1207 
1208 
1209  default:
1210  elog(ERROR, "unrecognized shared classId: %u", classId);
1211  }
1212 }
1213 
1214 
1215 /*
1216  * storeObjectDescription
1217  * Append the description of a dependent object to "descs"
1218  *
1219  * While searching for dependencies of a shared object, we stash the
1220  * descriptions of dependent objects we find in a single string, which we
1221  * later pass to ereport() in the DETAIL field when somebody attempts to
1222  * drop a referenced shared object.
1223  *
1224  * When type is LOCAL_OBJECT or SHARED_OBJECT, we expect object to be the
1225  * dependent object, deptype is the dependency type, and count is not used.
1226  * When type is REMOTE_OBJECT, we expect object to be the database object,
1227  * and count to be nonzero; deptype is not used in this case.
1228  */
1229 static void
1232  ObjectAddress *object,
1233  SharedDependencyType deptype,
1234  int count)
1235 {
1236  char *objdesc = getObjectDescription(object, false);
1237 
1238  /*
1239  * An object being dropped concurrently doesn't need to be reported.
1240  */
1241  if (objdesc == NULL)
1242  return;
1243 
1244  /* separate entries with a newline */
1245  if (descs->len != 0)
1246  appendStringInfoChar(descs, '\n');
1247 
1248  switch (type)
1249  {
1250  case LOCAL_OBJECT:
1251  case SHARED_OBJECT:
1252  if (deptype == SHARED_DEPENDENCY_OWNER)
1253  appendStringInfo(descs, _("owner of %s"), objdesc);
1254  else if (deptype == SHARED_DEPENDENCY_ACL)
1255  appendStringInfo(descs, _("privileges for %s"), objdesc);
1256  else if (deptype == SHARED_DEPENDENCY_POLICY)
1257  appendStringInfo(descs, _("target of %s"), objdesc);
1258  else if (deptype == SHARED_DEPENDENCY_TABLESPACE)
1259  appendStringInfo(descs, _("tablespace for %s"), objdesc);
1260  else
1261  elog(ERROR, "unrecognized dependency type: %d",
1262  (int) deptype);
1263  break;
1264 
1265  case REMOTE_OBJECT:
1266  /* translator: %s will always be "database %s" */
1267  appendStringInfo(descs, ngettext("%d object in %s",
1268  "%d objects in %s",
1269  count),
1270  count, objdesc);
1271  break;
1272 
1273  default:
1274  elog(ERROR, "unrecognized object type: %d", type);
1275  }
1276 
1277  pfree(objdesc);
1278 }
1279 
1280 
1281 /*
1282  * shdepDropOwned
1283  *
1284  * Drop the objects owned by any one of the given RoleIds. If a role has
1285  * access to an object, the grant will be removed as well (but the object
1286  * will not, of course).
1287  *
1288  * We can revoke grants immediately while doing the scan, but drops are
1289  * saved up and done all at once with performMultipleDeletions. This
1290  * is necessary so that we don't get failures from trying to delete
1291  * interdependent objects in the wrong order.
1292  */
1293 void
1294 shdepDropOwned(List *roleids, DropBehavior behavior)
1295 {
1296  Relation sdepRel;
1297  ListCell *cell;
1298  ObjectAddresses *deleteobjs;
1299 
1300  deleteobjs = new_object_addresses();
1301 
1302  /*
1303  * We don't need this strong a lock here, but we'll call routines that
1304  * acquire RowExclusiveLock. Better get that right now to avoid potential
1305  * deadlock failures.
1306  */
1307  sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);
1308 
1309  /*
1310  * For each role, find the dependent objects and drop them using the
1311  * regular (non-shared) dependency management.
1312  */
1313  foreach(cell, roleids)
1314  {
1315  Oid roleid = lfirst_oid(cell);
1316  ScanKeyData key[2];
1317  SysScanDesc scan;
1318  HeapTuple tuple;
1319 
1320  /* Doesn't work for pinned objects */
1321  if (IsPinnedObject(AuthIdRelationId, roleid))
1322  {
1323  ObjectAddress obj;
1324 
1325  obj.classId = AuthIdRelationId;
1326  obj.objectId = roleid;
1327  obj.objectSubId = 0;
1328 
1329  ereport(ERROR,
1330  (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
1331  errmsg("cannot drop objects owned by %s because they are "
1332  "required by the database system",
1333  getObjectDescription(&obj, false))));
1334  }
1335 
1336  ScanKeyInit(&key[0],
1337  Anum_pg_shdepend_refclassid,
1338  BTEqualStrategyNumber, F_OIDEQ,
1339  ObjectIdGetDatum(AuthIdRelationId));
1340  ScanKeyInit(&key[1],
1341  Anum_pg_shdepend_refobjid,
1342  BTEqualStrategyNumber, F_OIDEQ,
1343  ObjectIdGetDatum(roleid));
1344 
1345  scan = systable_beginscan(sdepRel, SharedDependReferenceIndexId, true,
1346  NULL, 2, key);
1347 
1348  while ((tuple = systable_getnext(scan)) != NULL)
1349  {
1350  Form_pg_shdepend sdepForm = (Form_pg_shdepend) GETSTRUCT(tuple);
1351  ObjectAddress obj;
1352 
1353  /*
1354  * We only operate on shared objects and objects in the current
1355  * database
1356  */
1357  if (sdepForm->dbid != MyDatabaseId &&
1358  sdepForm->dbid != InvalidOid)
1359  continue;
1360 
1361  switch (sdepForm->deptype)
1362  {
1363  /* Shouldn't happen */
1365  elog(ERROR, "unexpected dependency type");
1366  break;
1367  case SHARED_DEPENDENCY_ACL:
1368  RemoveRoleFromObjectACL(roleid,
1369  sdepForm->classid,
1370  sdepForm->objid);
1371  break;
1373 
1374  /*
1375  * Try to remove role from policy; if unable to, remove
1376  * policy.
1377  */
1378  if (!RemoveRoleFromObjectPolicy(roleid,
1379  sdepForm->classid,
1380  sdepForm->objid))
1381  {
1382  obj.classId = sdepForm->classid;
1383  obj.objectId = sdepForm->objid;
1384  obj.objectSubId = sdepForm->objsubid;
1385 
1386  /*
1387  * Acquire lock on object, then verify this dependency
1388  * is still relevant. If not, the object might have
1389  * been dropped or the policy modified. Ignore the
1390  * object in that case.
1391  */
1392  AcquireDeletionLock(&obj, 0);
1393  if (!systable_recheck_tuple(scan, tuple))
1394  {
1395  ReleaseDeletionLock(&obj);
1396  break;
1397  }
1398  add_exact_object_address(&obj, deleteobjs);
1399  }
1400  break;
1402  /* If a local object, save it for deletion below */
1403  if (sdepForm->dbid == MyDatabaseId)
1404  {
1405  obj.classId = sdepForm->classid;
1406  obj.objectId = sdepForm->objid;
1407  obj.objectSubId = sdepForm->objsubid;
1408  /* as above */
1409  AcquireDeletionLock(&obj, 0);
1410  if (!systable_recheck_tuple(scan, tuple))
1411  {
1412  ReleaseDeletionLock(&obj);
1413  break;
1414  }
1415  add_exact_object_address(&obj, deleteobjs);
1416  }
1417  break;
1418  }
1419  }
1420 
1421  systable_endscan(scan);
1422  }
1423 
1424  /*
1425  * For stability of deletion-report ordering, sort the objects into
1426  * approximate reverse creation order before deletion. (This might also
1427  * make the deletion go a bit faster, since there's less chance of having
1428  * to rearrange the objects due to dependencies.)
1429  */
1430  sort_object_addresses(deleteobjs);
1431 
1432  /* the dependency mechanism does the actual work */
1433  performMultipleDeletions(deleteobjs, behavior, 0);
1434 
1435  table_close(sdepRel, RowExclusiveLock);
1436 
1437  free_object_addresses(deleteobjs);
1438 }
1439 
1440 /*
1441  * shdepReassignOwned
1442  *
1443  * Change the owner of objects owned by any of the roles in roleids to
1444  * newrole. Grants are not touched.
1445  */
1446 void
1447 shdepReassignOwned(List *roleids, Oid newrole)
1448 {
1449  Relation sdepRel;
1450  ListCell *cell;
1451 
1452  /*
1453  * We don't need this strong a lock here, but we'll call routines that
1454  * acquire RowExclusiveLock. Better get that right now to avoid potential
1455  * deadlock problems.
1456  */
1457  sdepRel = table_open(SharedDependRelationId, RowExclusiveLock);
1458 
1459  foreach(cell, roleids)
1460  {
1461  SysScanDesc scan;
1462  ScanKeyData key[2];
1463  HeapTuple tuple;
1464  Oid roleid = lfirst_oid(cell);
1465 
1466  /* Refuse to work on pinned roles */
1467  if (IsPinnedObject(AuthIdRelationId, roleid))
1468  {
1469  ObjectAddress obj;
1470 
1471  obj.classId = AuthIdRelationId;
1472  obj.objectId = roleid;
1473  obj.objectSubId = 0;
1474 
1475  ereport(ERROR,
1476  (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
1477  errmsg("cannot reassign ownership of objects owned by %s because they are required by the database system",
1478  getObjectDescription(&obj, false))));
1479 
1480  /*
1481  * There's no need to tell the whole truth, which is that we
1482  * didn't track these dependencies at all ...
1483  */
1484  }
1485 
1486  ScanKeyInit(&key[0],
1487  Anum_pg_shdepend_refclassid,
1488  BTEqualStrategyNumber, F_OIDEQ,
1489  ObjectIdGetDatum(AuthIdRelationId));
1490  ScanKeyInit(&key[1],
1491  Anum_pg_shdepend_refobjid,
1492  BTEqualStrategyNumber, F_OIDEQ,
1493  ObjectIdGetDatum(roleid));
1494 
1495  scan = systable_beginscan(sdepRel, SharedDependReferenceIndexId, true,
1496  NULL, 2, key);
1497 
1498  while ((tuple = systable_getnext(scan)) != NULL)
1499  {
1500  Form_pg_shdepend sdepForm = (Form_pg_shdepend) GETSTRUCT(tuple);
1501  MemoryContext cxt,
1502  oldcxt;
1503 
1504  /*
1505  * We only operate on shared objects and objects in the current
1506  * database
1507  */
1508  if (sdepForm->dbid != MyDatabaseId &&
1509  sdepForm->dbid != InvalidOid)
1510  continue;
1511 
1512  /* We leave non-owner dependencies alone */
1513  if (sdepForm->deptype != SHARED_DEPENDENCY_OWNER)
1514  continue;
1515 
1516  /*
1517  * The various ALTER OWNER routines tend to leak memory in
1518  * CurrentMemoryContext. That's not a problem when they're only
1519  * called once per command; but in this usage where we might be
1520  * touching many objects, it can amount to a serious memory leak.
1521  * Fix that by running each call in a short-lived context.
1522  */
1524  "shdepReassignOwned",
1526  oldcxt = MemoryContextSwitchTo(cxt);
1527 
1528  /* Issue the appropriate ALTER OWNER call */
1529  switch (sdepForm->classid)
1530  {
1531  case TypeRelationId:
1532  AlterTypeOwner_oid(sdepForm->objid, newrole, true);
1533  break;
1534 
1535  case NamespaceRelationId:
1536  AlterSchemaOwner_oid(sdepForm->objid, newrole);
1537  break;
1538 
1539  case RelationRelationId:
1540 
1541  /*
1542  * Pass recursing = true so that we don't fail on indexes,
1543  * owned sequences, etc when we happen to visit them
1544  * before their parent table.
1545  */
1546  ATExecChangeOwner(sdepForm->objid, newrole, true, AccessExclusiveLock);
1547  break;
1548 
1549  case DefaultAclRelationId:
1550 
1551  /*
1552  * Ignore default ACLs; they should be handled by DROP
1553  * OWNED, not REASSIGN OWNED.
1554  */
1555  break;
1556 
1557  case UserMappingRelationId:
1558  /* ditto */
1559  break;
1560 
1561  case ForeignServerRelationId:
1562  AlterForeignServerOwner_oid(sdepForm->objid, newrole);
1563  break;
1564 
1565  case ForeignDataWrapperRelationId:
1566  AlterForeignDataWrapperOwner_oid(sdepForm->objid, newrole);
1567  break;
1568 
1569  case EventTriggerRelationId:
1570  AlterEventTriggerOwner_oid(sdepForm->objid, newrole);
1571  break;
1572 
1573  case PublicationRelationId:
1574  AlterPublicationOwner_oid(sdepForm->objid, newrole);
1575  break;
1576 
1577  case SubscriptionRelationId:
1578  AlterSubscriptionOwner_oid(sdepForm->objid, newrole);
1579  break;
1580 
1581  /* Generic alter owner cases */
1582  case CollationRelationId:
1583  case ConversionRelationId:
1584  case OperatorRelationId:
1585  case ProcedureRelationId:
1586  case LanguageRelationId:
1587  case LargeObjectRelationId:
1588  case OperatorFamilyRelationId:
1589  case OperatorClassRelationId:
1590  case ExtensionRelationId:
1591  case StatisticExtRelationId:
1592  case TableSpaceRelationId:
1593  case DatabaseRelationId:
1594  case TSConfigRelationId:
1595  case TSDictionaryRelationId:
1596  {
1597  Oid classId = sdepForm->classid;
1598  Relation catalog;
1599 
1600  if (classId == LargeObjectRelationId)
1601  classId = LargeObjectMetadataRelationId;
1602 
1603  catalog = table_open(classId, RowExclusiveLock);
1604 
1605  AlterObjectOwner_internal(catalog, sdepForm->objid,
1606  newrole);
1607 
1608  table_close(catalog, NoLock);
1609  }
1610  break;
1611 
1612  default:
1613  elog(ERROR, "unexpected classid %u", sdepForm->classid);
1614  break;
1615  }
1616 
1617  /* Clean up */
1618  MemoryContextSwitchTo(oldcxt);
1619  MemoryContextDelete(cxt);
1620 
1621  /* Make sure the next iteration will see my changes */
1623  }
1624 
1625  systable_endscan(scan);
1626  }
1627 
1628  table_close(sdepRel, RowExclusiveLock);
1629 }
void RemoveRoleFromObjectACL(Oid roleid, Oid classid, Oid objid)
Definition: aclchk.c:1436
void AlterObjectOwner_internal(Relation rel, Oid objectId, Oid new_ownerId)
Definition: alter.c:936
char * get_tablespace_name(Oid spc_oid)
Definition: tablespace.c:1520
static Datum values[MAXATTR]
Definition: bootstrap.c:156
signed int int32
Definition: c.h:429
#define ngettext(s, p, n)
Definition: c.h:1179
#define OidIsValid(objectId)
Definition: c.h:710
bool IsPinnedObject(Oid classId, Oid objectId)
Definition: catalog.c:313
bool IsSharedRelation(Oid relationId)
Definition: catalog.c:245
char * get_database_name(Oid dbid)
Definition: dbcommands.c:2994
void performMultipleDeletions(const ObjectAddresses *objects, DropBehavior behavior, int flags)
Definition: dependency.c:376
void sort_object_addresses(ObjectAddresses *addrs)
Definition: dependency.c:2730
void AcquireDeletionLock(const ObjectAddress *object, int flags)
Definition: dependency.c:1534
void ReleaseDeletionLock(const ObjectAddress *object)
Definition: dependency.c:1563
ObjectAddresses * new_object_addresses(void)
Definition: dependency.c:2447
void add_exact_object_address(const ObjectAddress *object, ObjectAddresses *addrs)
Definition: dependency.c:2502
void free_object_addresses(ObjectAddresses *addrs)
Definition: dependency.c:2742
SharedDependencyType
Definition: dependency.h:73
@ SHARED_DEPENDENCY_TABLESPACE
Definition: dependency.h:77
@ SHARED_DEPENDENCY_INVALID
Definition: dependency.h:78
@ SHARED_DEPENDENCY_POLICY
Definition: dependency.h:76
@ SHARED_DEPENDENCY_ACL
Definition: dependency.h:75
@ SHARED_DEPENDENCY_OWNER
Definition: dependency.h:74
int errcode(int sqlerrcode)
Definition: elog.c:693
int errmsg(const char *fmt,...)
Definition: elog.c:904
#define _(x)
Definition: elog.c:89
#define ERROR
Definition: elog.h:33
#define elog(elevel,...)
Definition: elog.h:218
#define ereport(elevel,...)
Definition: elog.h:143
void AlterEventTriggerOwner_oid(Oid trigOid, Oid newOwnerId)
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
Definition: execTuples.c:1552
void ExecDropSingleTupleTableSlot(TupleTableSlot *slot)
Definition: execTuples.c:1254
const TupleTableSlotOps TTSOpsHeapTuple
Definition: execTuples.c:84
TupleTableSlot * MakeSingleTupleTableSlot(TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1238
void AlterForeignServerOwner_oid(Oid srvId, Oid newOwnerId)
Definition: foreigncmds.c:450
void AlterForeignDataWrapperOwner_oid(Oid fwdId, Oid newOwnerId)
Definition: foreigncmds.c:313
void systable_endscan(SysScanDesc sysscan)
Definition: genam.c:598
bool systable_recheck_tuple(SysScanDesc sysscan, HeapTuple tup)
Definition: genam.c:564
HeapTuple systable_getnext(SysScanDesc sysscan)
Definition: genam.c:505
SysScanDesc systable_beginscan(Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)
Definition: genam.c:386
Oid MyDatabaseId
Definition: globals.c:89
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, Datum *values, bool *isnull)
Definition: heaptuple.c:1020
HeapTuple heap_copytuple(HeapTuple tuple)
Definition: heaptuple.c:680
void heap_freetuple(HeapTuple htup)
Definition: heaptuple.c:1338
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:649
void CatalogTupleUpdate(Relation heapRel, ItemPointer otid, HeapTuple tup)
Definition: indexing.c:301
void CatalogTuplesMultiInsertWithInfo(Relation heapRel, TupleTableSlot **slot, int ntuples, CatalogIndexState indstate)
Definition: indexing.c:261
void CatalogCloseIndexes(CatalogIndexState indstate)
Definition: indexing.c:61
void CatalogTupleInsert(Relation heapRel, HeapTuple tup)
Definition: indexing.c:221
CatalogIndexState CatalogOpenIndexes(Relation heapRel)
Definition: indexing.c:43
void CatalogTupleDelete(Relation heapRel, ItemPointer tid)
Definition: indexing.c:350
#define MAX_CATALOG_MULTI_INSERT_BYTES
Definition: indexing.h:33
int b
Definition: isn.c:70
int a
Definition: isn.c:69
int i
Definition: isn.c:73
Assert(fmt[strlen(fmt) - 1] !='\n')
List * lappend(List *list, void *datum)
Definition: list.c:336
void list_free_deep(List *list)
Definition: list.c:1519
void LockSharedObject(Oid classid, Oid objid, uint16 objsubid, LOCKMODE lockmode)
Definition: lmgr.c:1046
#define NoLock
Definition: lockdefs.h:34
#define AccessExclusiveLock
Definition: lockdefs.h:43
#define AccessShareLock
Definition: lockdefs.h:36
#define RowExclusiveLock
Definition: lockdefs.h:38
void pfree(void *pointer)
Definition: mcxt.c:1175
MemoryContext CurrentMemoryContext
Definition: mcxt.c:42
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1188
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:218
void * palloc(Size size)
Definition: mcxt.c:1068
#define AllocSetContextCreate
Definition: memutils.h:173
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:197
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:406
char * getObjectDescription(const ObjectAddress *object, bool missing_ok)
#define ObjectAddressSet(addr, class_id, object_id)
Definition: objectaddress.h:40
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
DropBehavior
Definition: parsenodes.h:2206
#define lfirst(lc)
Definition: pg_list.h:169
#define NIL
Definition: pg_list.h:65
#define lfirst_oid(lc)
Definition: pg_list.h:171
static void shdepDropDependency(Relation sdepRel, Oid classId, Oid objectId, int32 objsubId, bool drop_subobjects, Oid refclassId, Oid refobjId, SharedDependencyType deptype)
Definition: pg_shdepend.c:1078
static int shared_dependency_comparator(const void *a, const void *b)
Definition: pg_shdepend.c:564
void dropDatabaseDependencies(Oid databaseId)
Definition: pg_shdepend.c:953
void changeDependencyOnOwner(Oid classId, Oid objectId, Oid newOwnerId)
Definition: pg_shdepend.c:312
static void getOidListDiff(Oid *list1, int *nlist1, Oid *list2, int *nlist2)
Definition: pg_shdepend.c:411
void copyTemplateDependencies(Oid templateDbId, Oid newDbId)
Definition: pg_shdepend.c:849
static Oid classIdGetDbId(Oid classId)
Definition: pg_shdepend.c:1144
void deleteSharedDependencyRecordsFor(Oid classId, Oid objectId, int32 objectSubId)
Definition: pg_shdepend.c:1001
void updateAclDependencies(Oid classId, Oid objectId, int32 objsubId, Oid ownerId, int noldmembers, Oid *oldmembers, int nnewmembers, Oid *newmembers)
Definition: pg_shdepend.c:481
#define MAX_REPORTED_DEPS
void recordDependencyOnOwner(Oid classId, Oid objectId, Oid owner)
Definition: pg_shdepend.c:164
bool checkSharedDependencies(Oid classId, Oid objectId, char **detail_msg, char **detail_log_msg)
Definition: pg_shdepend.c:630
void recordDependencyOnTablespace(Oid classId, Oid objectId, Oid tablespace)
Definition: pg_shdepend.c:360
static void shdepAddDependency(Relation sdepRel, Oid classId, Oid objectId, int32 objsubId, Oid refclassId, Oid refobjId, SharedDependencyType deptype)
Definition: pg_shdepend.c:1023
void shdepDropOwned(List *roleids, DropBehavior behavior)
Definition: pg_shdepend.c:1294
static void storeObjectDescription(StringInfo descs, SharedDependencyObjectType type, ObjectAddress *object, SharedDependencyType deptype, int count)
Definition: pg_shdepend.c:1230
void recordSharedDependencyOn(ObjectAddress *depender, ObjectAddress *referenced, SharedDependencyType deptype)
Definition: pg_shdepend.c:121
void shdepLockAndCheckObject(Oid classId, Oid objectId)
Definition: pg_shdepend.c:1165
void changeDependencyOnTablespace(Oid classId, Oid objectId, Oid newTablespaceId)
Definition: pg_shdepend.c:381
SharedDependencyObjectType
Definition: pg_shdepend.c:72
@ SHARED_OBJECT
Definition: pg_shdepend.c:74
@ LOCAL_OBJECT
Definition: pg_shdepend.c:73
@ REMOTE_OBJECT
Definition: pg_shdepend.c:75
void shdepReassignOwned(List *roleids, Oid newrole)
Definition: pg_shdepend.c:1447
static void shdepChangeDep(Relation sdepRel, Oid classid, Oid objid, int32 objsubid, Oid refclassid, Oid refobjid, SharedDependencyType deptype)
Definition: pg_shdepend.c:202
FormData_pg_shdepend
Definition: pg_shdepend.h:66
FormData_pg_shdepend * Form_pg_shdepend
Definition: pg_shdepend.h:73
char * tablespace
Definition: pgbench.c:229
bool RemoveRoleFromObjectPolicy(Oid roleid, Oid classid, Oid policy_id)
Definition: policy.c:419
#define qsort(a, b, c, d)
Definition: port.h:495
uintptr_t Datum
Definition: postgres.h:411
#define ObjectIdGetDatum(X)
Definition: postgres.h:551
#define Int32GetDatum(X)
Definition: postgres.h:523
#define CharGetDatum(X)
Definition: postgres.h:460
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
void AlterPublicationOwner_oid(Oid subid, Oid newOwnerId)
#define RelationGetDescr(relation)
Definition: rel.h:515
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
Definition: scankey.c:76
void AlterSchemaOwner_oid(Oid oid, Oid newOwnerId)
Definition: schemacmds.c:277
#define BTEqualStrategyNumber
Definition: stratnum.h:31
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:188
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
ItemPointerData t_self
Definition: htup.h:65
Definition: pg_list.h:51
TupleDesc rd_att
Definition: rel.h:110
ObjectAddress object
Definition: pg_shdepend.c:80
SharedDependencyObjectType objtype
Definition: pg_shdepend.c:82
Datum * tts_values
Definition: tuptable.h:126
void AlterSubscriptionOwner_oid(Oid subid, Oid newOwnerId)
@ AUTHOID
Definition: syscache.h:45
#define SearchSysCacheExists1(cacheId, key1)
Definition: syscache.h:188
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:167
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:39
void ATExecChangeOwner(Oid relationOid, Oid newOwnerId, bool recursing, LOCKMODE lockmode)
Definition: tablecmds.c:13670
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
void AlterTypeOwner_oid(Oid typeOid, Oid newOwnerId, bool hasDependEntry)
Definition: typecmds.c:3787
void CommandCounterIncrement(void)
Definition: xact.c:1074