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