Debian Codegraph @

src/backend/commands/alter.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * alter.c
4 * Drivers for generic alter commands
5 *
6 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/commands/alter.c
12 *
13 *-------------------------------------------------------------------------
14 */
15 #include "postgres.h"
16
17 #include "access/htup_details.h"
18 #include "access/relation.h"
19 #include "access/table.h"
20 #include "catalog/dependency.h"
21 #include "catalog/indexing.h"
22 #include "catalog/namespace.h"
23 #include "catalog/objectaccess.h"
24 #include "catalog/pg_collation.h"
25 #include "catalog/pg_conversion.h"
26 #include "catalog/pg_database_d.h"
27 #include "catalog/pg_event_trigger.h"
28 #include "catalog/pg_foreign_data_wrapper.h"
29 #include "catalog/pg_foreign_server.h"
30 #include "catalog/pg_language.h"
31 #include "catalog/pg_largeobject.h"
32 #include "catalog/pg_largeobject_metadata.h"
33 #include "catalog/pg_namespace.h"
34 #include "catalog/pg_opclass.h"
35 #include "catalog/pg_operator.h"
36 #include "catalog/pg_opfamily.h"
37 #include "catalog/pg_proc.h"
38 #include "catalog/pg_statistic_ext.h"
39 #include "catalog/pg_subscription.h"
40 #include "catalog/pg_ts_config.h"
41 #include "catalog/pg_ts_dict.h"
42 #include "catalog/pg_ts_parser.h"
43 #include "catalog/pg_ts_template.h"
44 #include "commands/alter.h"
45 #include "commands/collationcmds.h"
46 #include "commands/dbcommands.h"
47 #include "commands/defrem.h"
48 #include "commands/event_trigger.h"
49 #include "commands/extension.h"
50 #include "commands/policy.h"
51 #include "commands/publicationcmds.h"
52 #include "commands/schemacmds.h"
53 #include "commands/subscriptioncmds.h"
54 #include "commands/tablecmds.h"
55 #include "commands/tablespace.h"
56 #include "commands/trigger.h"
57 #include "commands/typecmds.h"
58 #include "commands/user.h"
59 #include "miscadmin.h"
60 #include "replication/logicalworker.h"
61 #include "rewrite/rewriteDefine.h"
62 #include "storage/lmgr.h"
63 #include "utils/acl.h"
64 #include "utils/builtins.h"
65 #include "utils/lsyscache.h"
66 #include "utils/rel.h"
67 #include "utils/syscache.h"
68
69 static Oid AlterObjectNamespace_internal(Relation rel, Oid objid, Oid nspOid);
70
71 /*
72 * Raise an error to the effect that an object of the given name is already
73 * present in the given namespace.
74 */
75 static void
76 report_name_conflict(Oid classId, const char *name)
77 {
78 char *msgfmt;
79
80 switch (classId)
81 {
82 case EventTriggerRelationId:
83 msgfmt = gettext_noop("event trigger \"%s\" already exists");
84 break;
85 case ForeignDataWrapperRelationId:
86 msgfmt = gettext_noop("foreign-data wrapper \"%s\" already exists");
87 break;
88 case ForeignServerRelationId:
89 msgfmt = gettext_noop("server \"%s\" already exists");
90 break;
91 case LanguageRelationId:
92 msgfmt = gettext_noop("language \"%s\" already exists");
93 break;
94 case PublicationRelationId:
95 msgfmt = gettext_noop("publication \"%s\" already exists");
96 break;
97 case SubscriptionRelationId:
98 msgfmt = gettext_noop("subscription \"%s\" already exists");
99 break;
100 default:
101 elog(ERROR, "unsupported object class: %u", classId);
102 break;
103 }
104
105 ereport(ERROR,
106 (errcode(ERRCODE_DUPLICATE_OBJECT),
107 errmsg(msgfmt, name)));
108 }
109
110 static void
111 report_namespace_conflict(Oid classId, const char *name, Oid nspOid)
112 {
113 char *msgfmt;
114
115 Assert(OidIsValid(nspOid));
116
117 switch (classId)
118 {
119 case ConversionRelationId:
120 Assert(OidIsValid(nspOid));
121 msgfmt = gettext_noop("conversion \"%s\" already exists in schema \"%s\"");
122 break;
123 case StatisticExtRelationId:
124 Assert(OidIsValid(nspOid));
125 msgfmt = gettext_noop("statistics object \"%s\" already exists in schema \"%s\"");
126 break;
127 case TSParserRelationId:
128 Assert(OidIsValid(nspOid));
129 msgfmt = gettext_noop("text search parser \"%s\" already exists in schema \"%s\"");
130 break;
131 case TSDictionaryRelationId:
132 Assert(OidIsValid(nspOid));
133 msgfmt = gettext_noop("text search dictionary \"%s\" already exists in schema \"%s\"");
134 break;
135 case TSTemplateRelationId:
136 Assert(OidIsValid(nspOid));
137 msgfmt = gettext_noop("text search template \"%s\" already exists in schema \"%s\"");
138 break;
139 case TSConfigRelationId:
140 Assert(OidIsValid(nspOid));
141 msgfmt = gettext_noop("text search configuration \"%s\" already exists in schema \"%s\"");
142 break;
143 default:
144 elog(ERROR, "unsupported object class: %u", classId);
145 break;
146 }
147
148 ereport(ERROR,
149 (errcode(ERRCODE_DUPLICATE_OBJECT),
150 errmsg(msgfmt, name, get_namespace_name(nspOid))));
151 }
152
153 /*
154 * AlterObjectRename_internal
155 *
156 * Generic function to rename the given object, for simple cases (won't
157 * work for tables, nor other cases where we need to do more than change
158 * the name column of a single catalog entry).
159 *
160 * rel: catalog relation containing object (RowExclusiveLock'd by caller)
161 * objectId: OID of object to be renamed
162 * new_name: CString representation of new name
163 */
164 static void
165 AlterObjectRename_internal(Relation rel, Oid objectId, const char *new_name)
166 {
167 Oid classId = RelationGetRelid(rel);
168 int oidCacheId = get_object_catcache_oid(classId);
169 int nameCacheId = get_object_catcache_name(classId);
170 AttrNumber Anum_name = get_object_attnum_name(classId);
171 AttrNumber Anum_namespace = get_object_attnum_namespace(classId);
172 AttrNumber Anum_owner = get_object_attnum_owner(classId);
173 HeapTuple oldtup;
174 HeapTuple newtup;
175 Datum datum;
176 bool isnull;
177 Oid namespaceId;
178 Oid ownerId;
179 char *old_name;
180 AclResult aclresult;
181 Datum *values;
182 bool *nulls;
183 bool *replaces;
184 NameData nameattrdata;
185
186 oldtup = SearchSysCache1(oidCacheId, ObjectIdGetDatum(objectId));
187 if (!HeapTupleIsValid(oldtup))
188 elog(ERROR, "cache lookup failed for object %u of catalog \"%s\"",
189 objectId, RelationGetRelationName(rel));
190
191 datum = heap_getattr(oldtup, Anum_name,
192 RelationGetDescr(rel), &isnull);
193 Assert(!isnull);
194 old_name = NameStr(*(DatumGetName(datum)));
195
196 /* Get OID of namespace */
197 if (Anum_namespace > 0)
198 {
199 datum = heap_getattr(oldtup, Anum_namespace,
200 RelationGetDescr(rel), &isnull);
201 Assert(!isnull);
202 namespaceId = DatumGetObjectId(datum);
203 }
204 else
205 namespaceId = InvalidOid;
206
207 /* Permission checks ... superusers can always do it */
208 if (!superuser())
209 {
210 /* Fail if object does not have an explicit owner */
211 if (Anum_owner <= 0)
212 ereport(ERROR,
213 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
214 errmsg("must be superuser to rename %s",
215 getObjectDescriptionOids(classId, objectId))));
216
217 /* Otherwise, must be owner of the existing object */
218 datum = heap_getattr(oldtup, Anum_owner,
219 RelationGetDescr(rel), &isnull);
220 Assert(!isnull);
221 ownerId = DatumGetObjectId(datum);
222
223 if (!has_privs_of_role(GetUserId(), DatumGetObjectId(ownerId)))
224 aclcheck_error(ACLCHECK_NOT_OWNER, get_object_type(classId, objectId),
225 old_name);
226
227 /* User must have CREATE privilege on the namespace */
228 if (OidIsValid(namespaceId))
229 {
230 aclresult = object_aclcheck(NamespaceRelationId, namespaceId, GetUserId(),
231 ACL_CREATE);
232 if (aclresult != ACLCHECK_OK)
233 aclcheck_error(aclresult, OBJECT_SCHEMA,
234 get_namespace_name(namespaceId));
235 }
236
237 if (classId == SubscriptionRelationId)
238 {
239 Form_pg_subscription form;
240
241 /* must have CREATE privilege on database */
242 aclresult = object_aclcheck(DatabaseRelationId, MyDatabaseId,
243 GetUserId(), ACL_CREATE);
244 if (aclresult != ACLCHECK_OK)
245 aclcheck_error(aclresult, OBJECT_DATABASE,
246 get_database_name(MyDatabaseId));
247
248 /*
249 * Don't allow non-superuser modification of a subscription with
250 * password_required=false.
251 */
252 form = (Form_pg_subscription) GETSTRUCT(oldtup);
253 if (!form->subpasswordrequired && !superuser())
254 ereport(ERROR,
255 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
256 errmsg("password_required=false is superuser-only"),
257 errhint("Subscriptions with the password_required option set to false may only be created or modified by the superuser.")));
258 }
259 }
260
261 /*
262 * Check for duplicate name (more friendly than unique-index failure).
263 * Since this is just a friendliness check, we can just skip it in cases
264 * where there isn't suitable support.
265 */
266 if (classId == ProcedureRelationId)
267 {
268 Form_pg_proc proc = (Form_pg_proc) GETSTRUCT(oldtup);
269
270 IsThereFunctionInNamespace(new_name, proc->pronargs,
271 &proc->proargtypes, proc->pronamespace);
272 }
273 else if (classId == CollationRelationId)
274 {
275 Form_pg_collation coll = (Form_pg_collation) GETSTRUCT(oldtup);
276
277 IsThereCollationInNamespace(new_name, coll->collnamespace);
278 }
279 else if (classId == OperatorClassRelationId)
280 {
281 Form_pg_opclass opc = (Form_pg_opclass) GETSTRUCT(oldtup);
282
283 IsThereOpClassInNamespace(new_name, opc->opcmethod,
284 opc->opcnamespace);
285 }
286 else if (classId == OperatorFamilyRelationId)
287 {
288 Form_pg_opfamily opf = (Form_pg_opfamily) GETSTRUCT(oldtup);
289
290 IsThereOpFamilyInNamespace(new_name, opf->opfmethod,
291 opf->opfnamespace);
292 }
293 else if (classId == SubscriptionRelationId)
294 {
295 if (SearchSysCacheExists2(SUBSCRIPTIONNAME,
296 ObjectIdGetDatum(MyDatabaseId),
297 CStringGetDatum(new_name)))
298 report_name_conflict(classId, new_name);
299
300 /* Also enforce regression testing naming rules, if enabled */
301 #ifdef ENFORCE_REGRESSION_TEST_NAME_RESTRICTIONS
302 if (strncmp(new_name, "regress_", 8) != 0)
303 elog(WARNING, "subscriptions created by regression test cases should have names starting with \"regress_\"");
304 #endif
305
306 /* Wake up related replication workers to handle this change quickly */
307 LogicalRepWorkersWakeupAtCommit(objectId);
308 }
309 else if (nameCacheId >= 0)
310 {
311 if (OidIsValid(namespaceId))
312 {
313 if (SearchSysCacheExists2(nameCacheId,
314 CStringGetDatum(new_name),
315 ObjectIdGetDatum(namespaceId)))
316 report_namespace_conflict(classId, new_name, namespaceId);
317 }
318 else
319 {
320 if (SearchSysCacheExists1(nameCacheId,
321 CStringGetDatum(new_name)))
322 report_name_conflict(classId, new_name);
323 }
324 }
325
326 /* Build modified tuple */
327 values = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(Datum));
328 nulls = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool));
329 replaces = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool));
330 namestrcpy(&nameattrdata, new_name);
331 values[Anum_name - 1] = NameGetDatum(&nameattrdata);
332 replaces[Anum_name - 1] = true;
333 newtup = heap_modify_tuple(oldtup, RelationGetDescr(rel),
334 values, nulls, replaces);
335
336 /* Perform actual update */
337 CatalogTupleUpdate(rel, &oldtup->t_self, newtup);
338
339 InvokeObjectPostAlterHook(classId, objectId, 0);
340
341 /* Do post catalog-update tasks */
342 if (classId == PublicationRelationId)
343 {
344 Form_pg_publication pub = (Form_pg_publication) GETSTRUCT(oldtup);
345
346 /*
347 * Invalidate relsynccache entries.
348 *
349 * Unlike ALTER PUBLICATION ADD/SET/DROP commands, renaming a
350 * publication does not impact the publication status of tables. So,
351 * we don't need to invalidate relcache to rebuild the rd_pubdesc.
352 * Instead, we invalidate only the relsyncache.
353 */
354 InvalidatePubRelSyncCache(pub->oid, pub->puballtables);
355 }
356
357 /* Release memory */
358 pfree(values);
359 pfree(nulls);
360 pfree(replaces);
361 heap_freetuple(newtup);
362
363 ReleaseSysCache(oldtup);
364 }
365
366 /*
367 * Executes an ALTER OBJECT / RENAME TO statement. Based on the object
368 * type, the function appropriate to that type is executed.
369 *
370 * Return value is the address of the renamed object.
371 */
372 ObjectAddress
373 ExecRenameStmt(RenameStmt *stmt)
374 {
375 switch (stmt->renameType)
376 {
377 case OBJECT_TABCONSTRAINT:
378 case OBJECT_DOMCONSTRAINT:
379 return RenameConstraint(stmt);
380
381 case OBJECT_DATABASE:
382 return RenameDatabase(stmt->subname, stmt->newname);
383
384 case OBJECT_ROLE:
385 return RenameRole(stmt->subname, stmt->newname);
386
387 case OBJECT_SCHEMA:
388 return RenameSchema(stmt->subname, stmt->newname);
389
390 case OBJECT_TABLESPACE:
391 return RenameTableSpace(stmt->subname, stmt->newname);
392
393 case OBJECT_TABLE:
394 case OBJECT_SEQUENCE:
395 case OBJECT_VIEW:
396 case OBJECT_MATVIEW:
397 case OBJECT_INDEX:
398 case OBJECT_FOREIGN_TABLE:
399 return RenameRelation(stmt);
400
401 case OBJECT_COLUMN:
402 case OBJECT_ATTRIBUTE:
403 return renameatt(stmt);
404
405 case OBJECT_RULE:
406 return RenameRewriteRule(stmt->relation, stmt->subname,
407 stmt->newname);
408
409 case OBJECT_TRIGGER:
410 return renametrig(stmt);
411
412 case OBJECT_POLICY:
413 return rename_policy(stmt);
414
415 case OBJECT_DOMAIN:
416 case OBJECT_TYPE:
417 return RenameType(stmt);
418
419 case OBJECT_AGGREGATE:
420 case OBJECT_COLLATION:
421 case OBJECT_CONVERSION:
422 case OBJECT_EVENT_TRIGGER:
423 case OBJECT_FDW:
424 case OBJECT_FOREIGN_SERVER:
425 case OBJECT_FUNCTION:
426 case OBJECT_OPCLASS:
427 case OBJECT_OPFAMILY:
428 case OBJECT_LANGUAGE:
429 case OBJECT_PROCEDURE:
430 case OBJECT_ROUTINE:
431 case OBJECT_STATISTIC_EXT:
432 case OBJECT_TSCONFIGURATION:
433 case OBJECT_TSDICTIONARY:
434 case OBJECT_TSPARSER:
435 case OBJECT_TSTEMPLATE:
436 case OBJECT_PUBLICATION:
437 case OBJECT_SUBSCRIPTION:
438 {
439 ObjectAddress address;
440 Relation catalog;
441
442 address = get_object_address(stmt->renameType,
443 stmt->object,
444 NULL,
445 AccessExclusiveLock, false);
446
447 catalog = table_open(address.classId, RowExclusiveLock);
448 AlterObjectRename_internal(catalog,
449 address.objectId,
450 stmt->newname);
451 table_close(catalog, RowExclusiveLock);
452
453 return address;
454 }
455
456 default:
457 elog(ERROR, "unrecognized rename stmt type: %d",
458 (int) stmt->renameType);
459 return InvalidObjectAddress; /* keep compiler happy */
460 }
461 }
462
463 /*
464 * Executes an ALTER OBJECT / [NO] DEPENDS ON EXTENSION statement.
465 *
466 * Return value is the address of the altered object. refAddress is an output
467 * argument which, if not null, receives the address of the object that the
468 * altered object now depends on.
469 */
470 ObjectAddress
471 ExecAlterObjectDependsStmt(AlterObjectDependsStmt *stmt, ObjectAddress *refAddress)
472 {
473 ObjectAddress address;
474 ObjectAddress refAddr;
475 Relation rel;
476
477 address =
478 get_object_address_rv(stmt->objectType, stmt->relation, (List *) stmt->object,
479 &rel, AccessExclusiveLock, false);
480
481 /*
482 * Verify that the user is entitled to run the command.
483 *
484 * We don't check any privileges on the extension, because that's not
485 * needed. The object owner is stipulating, by running this command, that
486 * the extension owner can drop the object whenever they feel like it,
487 * which is not considered a problem.
488 */
489 check_object_ownership(GetUserId(),
490 stmt->objectType, address, stmt->object, rel);
491
492 /*
493 * If a relation was involved, it would have been opened and locked. We
494 * don't need the relation here, but we'll retain the lock until commit.
495 */
496 if (rel)
497 table_close(rel, NoLock);
498
499 refAddr = get_object_address(OBJECT_EXTENSION, (Node *) stmt->extname,
500 NULL, AccessExclusiveLock, false);
501 if (refAddress)
502 *refAddress = refAddr;
503
504 if (stmt->remove)
505 {
506 deleteDependencyRecordsForSpecific(address.classId, address.objectId,
507 DEPENDENCY_AUTO_EXTENSION,
508 refAddr.classId, refAddr.objectId);
509 }
510 else
511 {
512 List *currexts;
513
514 /* Avoid duplicates */
515 currexts = getAutoExtensionsOfObject(address.classId,
516 address.objectId);
517 if (!list_member_oid(currexts, refAddr.objectId))
518 recordDependencyOn(&address, &refAddr, DEPENDENCY_AUTO_EXTENSION);
519 }
520
521 return address;
522 }
523
524 /*
525 * Executes an ALTER OBJECT / SET SCHEMA statement. Based on the object
526 * type, the function appropriate to that type is executed.
527 *
528 * Return value is that of the altered object.
529 *
530 * oldSchemaAddr is an output argument which, if not NULL, is set to the object
531 * address of the original schema.
532 */
533 ObjectAddress
534 ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *stmt,
535 ObjectAddress *oldSchemaAddr)
536 {
537 ObjectAddress address;
538 Oid oldNspOid;
539
540 switch (stmt->objectType)
541 {
542 case OBJECT_EXTENSION:
543 address = AlterExtensionNamespace(strVal(stmt->object), stmt->newschema,
544 oldSchemaAddr ? &oldNspOid : NULL);
545 break;
546
547 case OBJECT_FOREIGN_TABLE:
548 case OBJECT_SEQUENCE:
549 case OBJECT_TABLE:
550 case OBJECT_VIEW:
551 case OBJECT_MATVIEW:
552 address = AlterTableNamespace(stmt,
553 oldSchemaAddr ? &oldNspOid : NULL);
554 break;
555
556 case OBJECT_DOMAIN:
557 case OBJECT_TYPE:
558 address = AlterTypeNamespace(castNode(List, stmt->object), stmt->newschema,
559 stmt->objectType,
560 oldSchemaAddr ? &oldNspOid : NULL);
561 break;
562
563 /* generic code path */
564 case OBJECT_AGGREGATE:
565 case OBJECT_COLLATION:
566 case OBJECT_CONVERSION:
567 case OBJECT_FUNCTION:
568 case OBJECT_OPERATOR:
569 case OBJECT_OPCLASS:
570 case OBJECT_OPFAMILY:
571 case OBJECT_PROCEDURE:
572 case OBJECT_ROUTINE:
573 case OBJECT_STATISTIC_EXT:
574 case OBJECT_TSCONFIGURATION:
575 case OBJECT_TSDICTIONARY:
576 case OBJECT_TSPARSER:
577 case OBJECT_TSTEMPLATE:
578 {
579 Relation catalog;
580 Oid classId;
581 Oid nspOid;
582
583 address = get_object_address(stmt->objectType,
584 stmt->object,
585 NULL,
586 AccessExclusiveLock,
587 false);
588 classId = address.classId;
589 catalog = table_open(classId, RowExclusiveLock);
590 nspOid = LookupCreationNamespace(stmt->newschema);
591
592 oldNspOid = AlterObjectNamespace_internal(catalog, address.objectId,
593 nspOid);
594 table_close(catalog, RowExclusiveLock);
595 }
596 break;
597
598 default:
599 elog(ERROR, "unrecognized AlterObjectSchemaStmt type: %d",
600 (int) stmt->objectType);
601 return InvalidObjectAddress; /* keep compiler happy */
602 }
603
604 if (oldSchemaAddr)
605 ObjectAddressSet(*oldSchemaAddr, NamespaceRelationId, oldNspOid);
606
607 return address;
608 }
609
610 /*
611 * Change an object's namespace given its classOid and object Oid.
612 *
613 * Objects that don't have a namespace should be ignored, as should
614 * dependent types such as array types.
615 *
616 * This function is currently used only by ALTER EXTENSION SET SCHEMA,
617 * so it only needs to cover object kinds that can be members of an
618 * extension, and it can silently ignore dependent types --- we assume
619 * those will be moved when their parent object is moved.
620 *
621 * Returns the OID of the object's previous namespace, or InvalidOid if
622 * object doesn't have a schema or was ignored due to being a dependent type.
623 */
624 Oid
625 AlterObjectNamespace_oid(Oid classId, Oid objid, Oid nspOid,
626 ObjectAddresses *objsMoved)
627 {
628 Oid oldNspOid = InvalidOid;
629
630 switch (classId)
631 {
632 case RelationRelationId:
633 {
634 Relation rel;
635
636 rel = relation_open(objid, AccessExclusiveLock);
637 oldNspOid = RelationGetNamespace(rel);
638
639 AlterTableNamespaceInternal(rel, oldNspOid, nspOid, objsMoved);
640
641 relation_close(rel, NoLock);
642 break;
643 }
644
645 case TypeRelationId:
646 oldNspOid = AlterTypeNamespace_oid(objid, nspOid, true, objsMoved);
647 break;
648
649 case ProcedureRelationId:
650 case CollationRelationId:
651 case ConversionRelationId:
652 case OperatorRelationId:
653 case OperatorClassRelationId:
654 case OperatorFamilyRelationId:
655 case StatisticExtRelationId:
656 case TSParserRelationId:
657 case TSDictionaryRelationId:
658 case TSTemplateRelationId:
659 case TSConfigRelationId:
660 {
661 Relation catalog;
662
663 catalog = table_open(classId, RowExclusiveLock);
664
665 oldNspOid = AlterObjectNamespace_internal(catalog, objid,
666 nspOid);
667
668 table_close(catalog, RowExclusiveLock);
669 }
670 break;
671
672 default:
673 /* ignore object types that don't have schema-qualified names */
674 Assert(get_object_attnum_namespace(classId) == InvalidAttrNumber);
675 }
676
677 return oldNspOid;
678 }
679
680 /*
681 * Generic function to change the namespace of a given object, for simple
682 * cases (won't work for tables, nor other cases where we need to do more
683 * than change the namespace column of a single catalog entry).
684 *
685 * rel: catalog relation containing object (RowExclusiveLock'd by caller)
686 * objid: OID of object to change the namespace of
687 * nspOid: OID of new namespace
688 *
689 * Returns the OID of the object's previous namespace.
690 */
691 static Oid
692 AlterObjectNamespace_internal(Relation rel, Oid objid, Oid nspOid)
693 {
694 Oid classId = RelationGetRelid(rel);
695 int oidCacheId = get_object_catcache_oid(classId);
696 int nameCacheId = get_object_catcache_name(classId);
697 AttrNumber Anum_name = get_object_attnum_name(classId);
698 AttrNumber Anum_namespace = get_object_attnum_namespace(classId);
699 AttrNumber Anum_owner = get_object_attnum_owner(classId);
700 Oid oldNspOid;
701 Datum name,
702 namespace;
703 bool isnull;
704 HeapTuple tup,
705 newtup;
706 Datum *values;
707 bool *nulls;
708 bool *replaces;
709
710 tup = SearchSysCacheCopy1(oidCacheId, ObjectIdGetDatum(objid));
711 if (!HeapTupleIsValid(tup)) /* should not happen */
712 elog(ERROR, "cache lookup failed for object %u of catalog \"%s\"",
713 objid, RelationGetRelationName(rel));
714
715 name = heap_getattr(tup, Anum_name, RelationGetDescr(rel), &isnull);
716 Assert(!isnull);
717 namespace = heap_getattr(tup, Anum_namespace, RelationGetDescr(rel),
718 &isnull);
719 Assert(!isnull);
720 oldNspOid = DatumGetObjectId(namespace);
721
722 /*
723 * If the object is already in the correct namespace, we don't need to do
724 * anything except fire the object access hook.
725 */
726 if (oldNspOid == nspOid)
727 {
728 InvokeObjectPostAlterHook(classId, objid, 0);
729 return oldNspOid;
730 }
731
732 /* Check basic namespace related issues */
733 CheckSetNamespace(oldNspOid, nspOid);
734
735 /* Permission checks ... superusers can always do it */
736 if (!superuser())
737 {
738 Datum owner;
739 Oid ownerId;
740 AclResult aclresult;
741
742 /* Fail if object does not have an explicit owner */
743 if (Anum_owner <= 0)
744 ereport(ERROR,
745 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
746 errmsg("must be superuser to set schema of %s",
747 getObjectDescriptionOids(classId, objid))));
748
749 /* Otherwise, must be owner of the existing object */
750 owner = heap_getattr(tup, Anum_owner, RelationGetDescr(rel), &isnull);
751 Assert(!isnull);
752 ownerId = DatumGetObjectId(owner);
753
754 if (!has_privs_of_role(GetUserId(), ownerId))
755 aclcheck_error(ACLCHECK_NOT_OWNER, get_object_type(classId, objid),
756 NameStr(*(DatumGetName(name))));
757
758 /* User must have CREATE privilege on new namespace */
759 aclresult = object_aclcheck(NamespaceRelationId, nspOid, GetUserId(), ACL_CREATE);
760 if (aclresult != ACLCHECK_OK)
761 aclcheck_error(aclresult, OBJECT_SCHEMA,
762 get_namespace_name(nspOid));
763 }
764
765 /*
766 * Check for duplicate name (more friendly than unique-index failure).
767 * Since this is just a friendliness check, we can just skip it in cases
768 * where there isn't suitable support.
769 */
770 if (classId == ProcedureRelationId)
771 {
772 Form_pg_proc proc = (Form_pg_proc) GETSTRUCT(tup);
773
774 IsThereFunctionInNamespace(NameStr(proc->proname), proc->pronargs,
775 &proc->proargtypes, nspOid);
776 }
777 else if (classId == CollationRelationId)
778 {
779 Form_pg_collation coll = (Form_pg_collation) GETSTRUCT(tup);
780
781 IsThereCollationInNamespace(NameStr(coll->collname), nspOid);
782 }
783 else if (classId == OperatorClassRelationId)
784 {
785 Form_pg_opclass opc = (Form_pg_opclass) GETSTRUCT(tup);
786
787 IsThereOpClassInNamespace(NameStr(opc->opcname),
788 opc->opcmethod, nspOid);
789 }
790 else if (classId == OperatorFamilyRelationId)
791 {
792 Form_pg_opfamily opf = (Form_pg_opfamily) GETSTRUCT(tup);
793
794 IsThereOpFamilyInNamespace(NameStr(opf->opfname),
795 opf->opfmethod, nspOid);
796 }
797 else if (nameCacheId >= 0 &&
798 SearchSysCacheExists2(nameCacheId, name,
799 ObjectIdGetDatum(nspOid)))
800 report_namespace_conflict(classId,
801 NameStr(*(DatumGetName(name))),
802 nspOid);
803
804 /* Build modified tuple */
805 values = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(Datum));
806 nulls = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool));
807 replaces = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool));
808 values[Anum_namespace - 1] = ObjectIdGetDatum(nspOid);
809 replaces[Anum_namespace - 1] = true;
810 newtup = heap_modify_tuple(tup, RelationGetDescr(rel),
811 values, nulls, replaces);
812
813 /* Perform actual update */
814 CatalogTupleUpdate(rel, &tup->t_self, newtup);
815
816 /* Release memory */
817 pfree(values);
818 pfree(nulls);
819 pfree(replaces);
820
821 /* update dependency to point to the new schema */
822 if (changeDependencyFor(classId, objid,
823 NamespaceRelationId, oldNspOid, nspOid) != 1)
824 elog(ERROR, "could not change schema dependency for object %u",
825 objid);
826
827 InvokeObjectPostAlterHook(classId, objid, 0);
828
829 return oldNspOid;
830 }
831
832 /*
833 * Executes an ALTER OBJECT / OWNER TO statement. Based on the object
834 * type, the function appropriate to that type is executed.
835 */
836 ObjectAddress
837 ExecAlterOwnerStmt(AlterOwnerStmt *stmt)
838 {
839 Oid newowner = get_rolespec_oid(stmt->newowner, false);
840
841 switch (stmt->objectType)
842 {
843 case OBJECT_DATABASE:
844 return AlterDatabaseOwner(strVal(stmt->object), newowner);
845
846 case OBJECT_SCHEMA:
847 return AlterSchemaOwner(strVal(stmt->object), newowner);
848
849 case OBJECT_TYPE:
850 case OBJECT_DOMAIN: /* same as TYPE */
851 return AlterTypeOwner(castNode(List, stmt->object), newowner, stmt->objectType);
852 break;
853
854 case OBJECT_FDW:
855 return AlterForeignDataWrapperOwner(strVal(stmt->object),
856 newowner);
857
858 case OBJECT_FOREIGN_SERVER:
859 return AlterForeignServerOwner(strVal(stmt->object),
860 newowner);
861
862 case OBJECT_EVENT_TRIGGER:
863 return AlterEventTriggerOwner(strVal(stmt->object),
864 newowner);
865
866 case OBJECT_PUBLICATION:
867 return AlterPublicationOwner(strVal(stmt->object),
868 newowner);
869
870 case OBJECT_SUBSCRIPTION:
871 return AlterSubscriptionOwner(strVal(stmt->object),
872 newowner);
873
874 /* Generic cases */
875 case OBJECT_AGGREGATE:
876 case OBJECT_COLLATION:
877 case OBJECT_CONVERSION:
878 case OBJECT_FUNCTION:
879 case OBJECT_LANGUAGE:
880 case OBJECT_LARGEOBJECT:
881 case OBJECT_OPERATOR:
882 case OBJECT_OPCLASS:
883 case OBJECT_OPFAMILY:
884 case OBJECT_PROCEDURE:
885 case OBJECT_ROUTINE:
886 case OBJECT_STATISTIC_EXT:
887 case OBJECT_TABLESPACE:
888 case OBJECT_TSDICTIONARY:
889 case OBJECT_TSCONFIGURATION:
890 {
891 ObjectAddress address;
892
893 address = get_object_address(stmt->objectType,
894 stmt->object,
895 NULL,
896 AccessExclusiveLock,
897 false);
898
899 AlterObjectOwner_internal(address.classId, address.objectId,
900 newowner);
901
902 return address;
903 }
904 break;
905
906 default:
907 elog(ERROR, "unrecognized AlterOwnerStmt type: %d",
908 (int) stmt->objectType);
909 return InvalidObjectAddress; /* keep compiler happy */
910 }
911 }
912
913 /*
914 * Generic function to change the ownership of a given object, for simple
915 * cases (won't work for tables, nor other cases where we need to do more than
916 * change the ownership column of a single catalog entry).
917 *
918 * classId: OID of catalog containing object
919 * objectId: OID of object to change the ownership of
920 * new_ownerId: OID of new object owner
921 *
922 * This will work on large objects, but we have to beware of the fact that
923 * classId isn't the OID of the catalog to modify in that case.
924 */
925 void
926 AlterObjectOwner_internal(Oid classId, Oid objectId, Oid new_ownerId)
927 {
928 /* For large objects, the catalog to modify is pg_largeobject_metadata */
929 Oid catalogId = (classId == LargeObjectRelationId) ? LargeObjectMetadataRelationId : classId;
930 AttrNumber Anum_oid = get_object_attnum_oid(catalogId);
931 AttrNumber Anum_owner = get_object_attnum_owner(catalogId);
932 AttrNumber Anum_namespace = get_object_attnum_namespace(catalogId);
933 AttrNumber Anum_acl = get_object_attnum_acl(catalogId);
934 AttrNumber Anum_name = get_object_attnum_name(catalogId);
935 Relation rel;
936 HeapTuple oldtup;
937 Datum datum;
938 bool isnull;
939 Oid old_ownerId;
940 Oid namespaceId = InvalidOid;
941
942 rel = table_open(catalogId, RowExclusiveLock);
943
944 /* Search tuple and lock it. */
945 oldtup =
946 get_catalog_object_by_oid_extended(rel, Anum_oid, objectId, true);
947 if (oldtup == NULL)
948 elog(ERROR, "cache lookup failed for object %u of catalog \"%s\"",
949 objectId, RelationGetRelationName(rel));
950
951 datum = heap_getattr(oldtup, Anum_owner,
952 RelationGetDescr(rel), &isnull);
953 Assert(!isnull);
954 old_ownerId = DatumGetObjectId(datum);
955
956 if (Anum_namespace != InvalidAttrNumber)
957 {
958 datum = heap_getattr(oldtup, Anum_namespace,
959 RelationGetDescr(rel), &isnull);
960 Assert(!isnull);
961 namespaceId = DatumGetObjectId(datum);
962 }
963
964 if (old_ownerId != new_ownerId)
965 {
966 AttrNumber nattrs;
967 HeapTuple newtup;
968 Datum *values;
969 bool *nulls;
970 bool *replaces;
971
972 /* Superusers can bypass permission checks */
973 if (!superuser())
974 {
975 /* must be owner */
976 if (!has_privs_of_role(GetUserId(), old_ownerId))
977 {
978 char *objname;
979 char namebuf[NAMEDATALEN];
980
981 if (Anum_name != InvalidAttrNumber)
982 {
983 datum = heap_getattr(oldtup, Anum_name,
984 RelationGetDescr(rel), &isnull);
985 Assert(!isnull);
986 objname = NameStr(*DatumGetName(datum));
987 }
988 else
989 {
990 snprintf(namebuf, sizeof(namebuf), "%u", objectId);
991 objname = namebuf;
992 }
993 aclcheck_error(ACLCHECK_NOT_OWNER,
994 get_object_type(catalogId, objectId),
995 objname);
996 }
997 /* Must be able to become new owner */
998 check_can_set_role(GetUserId(), new_ownerId);
999
1000 /* New owner must have CREATE privilege on namespace */
1001 if (OidIsValid(namespaceId))
1002 {
1003 AclResult aclresult;
1004
1005 aclresult = object_aclcheck(NamespaceRelationId, namespaceId, new_ownerId,
1006 ACL_CREATE);
1007 if (aclresult != ACLCHECK_OK)
1008 aclcheck_error(aclresult, OBJECT_SCHEMA,
1009 get_namespace_name(namespaceId));
1010 }
1011 }
1012
1013 /* Build a modified tuple */
1014 nattrs = RelationGetNumberOfAttributes(rel);
1015 values = palloc0(nattrs * sizeof(Datum));
1016 nulls = palloc0(nattrs * sizeof(bool));
1017 replaces = palloc0(nattrs * sizeof(bool));
1018 values[Anum_owner - 1] = ObjectIdGetDatum(new_ownerId);
1019 replaces[Anum_owner - 1] = true;
1020
1021 /*
1022 * Determine the modified ACL for the new owner. This is only
1023 * necessary when the ACL is non-null.
1024 */
1025 if (Anum_acl != InvalidAttrNumber)
1026 {
1027 datum = heap_getattr(oldtup,
1028 Anum_acl, RelationGetDescr(rel), &isnull);
1029 if (!isnull)
1030 {
1031 Acl *newAcl;
1032
1033 newAcl = aclnewowner(DatumGetAclP(datum),
1034 old_ownerId, new_ownerId);
1035 values[Anum_acl - 1] = PointerGetDatum(newAcl);
1036 replaces[Anum_acl - 1] = true;
1037 }
1038 }
1039
1040 newtup = heap_modify_tuple(oldtup, RelationGetDescr(rel),
1041 values, nulls, replaces);
1042
1043 /* Perform actual update */
1044 CatalogTupleUpdate(rel, &newtup->t_self, newtup);
1045
1046 UnlockTuple(rel, &oldtup->t_self, InplaceUpdateTupleLock);
1047
1048 /* Update owner dependency reference */
1049 changeDependencyOnOwner(classId, objectId, new_ownerId);
1050
1051 /* Release memory */
1052 pfree(values);
1053 pfree(nulls);
1054 pfree(replaces);
1055 }
1056 else
1057 UnlockTuple(rel, &oldtup->t_self, InplaceUpdateTupleLock);
1058
1059 /* Note the post-alter hook gets classId not catalogId */
1060 InvokeObjectPostAlterHook(classId, objectId, 0);
1061
1062 table_close(rel, RowExclusiveLock);
1063 }