Line data Source code
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 24 : report_name_conflict(Oid classId, const char *name)
77 : {
78 : char *msgfmt;
79 :
80 24 : switch (classId)
81 : {
82 6 : case EventTriggerRelationId:
83 6 : msgfmt = gettext_noop("event trigger \"%s\" already exists");
84 6 : break;
85 6 : case ForeignDataWrapperRelationId:
86 6 : msgfmt = gettext_noop("foreign-data wrapper \"%s\" already exists");
87 6 : break;
88 6 : case ForeignServerRelationId:
89 6 : msgfmt = gettext_noop("server \"%s\" already exists");
90 6 : break;
91 6 : case LanguageRelationId:
92 6 : msgfmt = gettext_noop("language \"%s\" already exists");
93 6 : break;
94 0 : case PublicationRelationId:
95 0 : msgfmt = gettext_noop("publication \"%s\" already exists");
96 0 : break;
97 0 : case SubscriptionRelationId:
98 0 : msgfmt = gettext_noop("subscription \"%s\" already exists");
99 0 : break;
100 0 : default:
101 0 : elog(ERROR, "unsupported object class: %u", classId);
102 : break;
103 : }
104 :
105 24 : ereport(ERROR,
106 : (errcode(ERRCODE_DUPLICATE_OBJECT),
107 : errmsg(msgfmt, name)));
108 : }
109 :
110 : static void
111 72 : report_namespace_conflict(Oid classId, const char *name, Oid nspOid)
112 : {
113 : char *msgfmt;
114 :
115 : Assert(OidIsValid(nspOid));
116 :
117 72 : switch (classId)
118 : {
119 12 : case ConversionRelationId:
120 : Assert(OidIsValid(nspOid));
121 12 : msgfmt = gettext_noop("conversion \"%s\" already exists in schema \"%s\"");
122 12 : break;
123 12 : case StatisticExtRelationId:
124 : Assert(OidIsValid(nspOid));
125 12 : msgfmt = gettext_noop("statistics object \"%s\" already exists in schema \"%s\"");
126 12 : break;
127 12 : case TSParserRelationId:
128 : Assert(OidIsValid(nspOid));
129 12 : msgfmt = gettext_noop("text search parser \"%s\" already exists in schema \"%s\"");
130 12 : break;
131 12 : case TSDictionaryRelationId:
132 : Assert(OidIsValid(nspOid));
133 12 : msgfmt = gettext_noop("text search dictionary \"%s\" already exists in schema \"%s\"");
134 12 : break;
135 12 : case TSTemplateRelationId:
136 : Assert(OidIsValid(nspOid));
137 12 : msgfmt = gettext_noop("text search template \"%s\" already exists in schema \"%s\"");
138 12 : break;
139 12 : case TSConfigRelationId:
140 : Assert(OidIsValid(nspOid));
141 12 : msgfmt = gettext_noop("text search configuration \"%s\" already exists in schema \"%s\"");
142 12 : break;
143 0 : default:
144 0 : elog(ERROR, "unsupported object class: %u", classId);
145 : break;
146 : }
147 :
148 72 : 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 428 : AlterObjectRename_internal(Relation rel, Oid objectId, const char *new_name)
166 : {
167 428 : Oid classId = RelationGetRelid(rel);
168 428 : int oidCacheId = get_object_catcache_oid(classId);
169 428 : int nameCacheId = get_object_catcache_name(classId);
170 428 : AttrNumber Anum_name = get_object_attnum_name(classId);
171 428 : AttrNumber Anum_namespace = get_object_attnum_namespace(classId);
172 428 : 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 428 : oldtup = SearchSysCache1(oidCacheId, ObjectIdGetDatum(objectId));
187 428 : if (!HeapTupleIsValid(oldtup))
188 0 : elog(ERROR, "cache lookup failed for object %u of catalog \"%s\"",
189 : objectId, RelationGetRelationName(rel));
190 :
191 428 : datum = heap_getattr(oldtup, Anum_name,
192 : RelationGetDescr(rel), &isnull);
193 : Assert(!isnull);
194 428 : old_name = NameStr(*(DatumGetName(datum)));
195 :
196 : /* Get OID of namespace */
197 428 : if (Anum_namespace > 0)
198 : {
199 270 : datum = heap_getattr(oldtup, Anum_namespace,
200 : RelationGetDescr(rel), &isnull);
201 : Assert(!isnull);
202 270 : namespaceId = DatumGetObjectId(datum);
203 : }
204 : else
205 158 : namespaceId = InvalidOid;
206 :
207 : /* Permission checks ... superusers can always do it */
208 428 : if (!superuser())
209 : {
210 : /* Fail if object does not have an explicit owner */
211 246 : if (Anum_owner <= 0)
212 0 : 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 246 : datum = heap_getattr(oldtup, Anum_owner,
219 : RelationGetDescr(rel), &isnull);
220 : Assert(!isnull);
221 246 : ownerId = DatumGetObjectId(datum);
222 :
223 246 : if (!has_privs_of_role(GetUserId(), DatumGetObjectId(ownerId)))
224 72 : aclcheck_error(ACLCHECK_NOT_OWNER, get_object_type(classId, objectId),
225 : old_name);
226 :
227 : /* User must have CREATE privilege on the namespace */
228 174 : if (OidIsValid(namespaceId))
229 : {
230 144 : aclresult = object_aclcheck(NamespaceRelationId, namespaceId, GetUserId(),
231 : ACL_CREATE);
232 144 : if (aclresult != ACLCHECK_OK)
233 0 : aclcheck_error(aclresult, OBJECT_SCHEMA,
234 0 : get_namespace_name(namespaceId));
235 : }
236 :
237 174 : if (classId == SubscriptionRelationId)
238 : {
239 : Form_pg_subscription form;
240 :
241 : /* must have CREATE privilege on database */
242 18 : aclresult = object_aclcheck(DatabaseRelationId, MyDatabaseId,
243 : GetUserId(), ACL_CREATE);
244 18 : if (aclresult != ACLCHECK_OK)
245 6 : aclcheck_error(aclresult, OBJECT_DATABASE,
246 6 : get_database_name(MyDatabaseId));
247 :
248 : /*
249 : * Don't allow non-superuser modification of a subscription with
250 : * password_required=false.
251 : */
252 12 : form = (Form_pg_subscription) GETSTRUCT(oldtup);
253 12 : if (!form->subpasswordrequired && !superuser())
254 0 : 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 350 : if (classId == ProcedureRelationId)
267 : {
268 72 : Form_pg_proc proc = (Form_pg_proc) GETSTRUCT(oldtup);
269 :
270 72 : IsThereFunctionInNamespace(new_name, proc->pronargs,
271 : &proc->proargtypes, proc->pronamespace);
272 : }
273 278 : else if (classId == CollationRelationId)
274 : {
275 12 : Form_pg_collation coll = (Form_pg_collation) GETSTRUCT(oldtup);
276 :
277 12 : IsThereCollationInNamespace(new_name, coll->collnamespace);
278 : }
279 266 : else if (classId == OperatorClassRelationId)
280 : {
281 18 : Form_pg_opclass opc = (Form_pg_opclass) GETSTRUCT(oldtup);
282 :
283 18 : IsThereOpClassInNamespace(new_name, opc->opcmethod,
284 : opc->opcnamespace);
285 : }
286 248 : else if (classId == OperatorFamilyRelationId)
287 : {
288 18 : Form_pg_opfamily opf = (Form_pg_opfamily) GETSTRUCT(oldtup);
289 :
290 18 : IsThereOpFamilyInNamespace(new_name, opf->opfmethod,
291 : opf->opfnamespace);
292 : }
293 230 : else if (classId == SubscriptionRelationId)
294 : {
295 26 : if (SearchSysCacheExists2(SUBSCRIPTIONNAME,
296 : ObjectIdGetDatum(MyDatabaseId),
297 : CStringGetDatum(new_name)))
298 0 : 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 26 : LogicalRepWorkersWakeupAtCommit(objectId);
308 : }
309 204 : else if (nameCacheId >= 0)
310 : {
311 204 : if (OidIsValid(namespaceId))
312 : {
313 96 : if (SearchSysCacheExists2(nameCacheId,
314 : CStringGetDatum(new_name),
315 : ObjectIdGetDatum(namespaceId)))
316 36 : report_namespace_conflict(classId, new_name, namespaceId);
317 : }
318 : else
319 : {
320 108 : if (SearchSysCacheExists1(nameCacheId,
321 : CStringGetDatum(new_name)))
322 24 : report_name_conflict(classId, new_name);
323 : }
324 : }
325 :
326 : /* Build modified tuple */
327 260 : values = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(Datum));
328 260 : nulls = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool));
329 260 : replaces = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool));
330 260 : namestrcpy(&nameattrdata, new_name);
331 260 : values[Anum_name - 1] = NameGetDatum(&nameattrdata);
332 260 : replaces[Anum_name - 1] = true;
333 260 : newtup = heap_modify_tuple(oldtup, RelationGetDescr(rel),
334 : values, nulls, replaces);
335 :
336 : /* Perform actual update */
337 260 : CatalogTupleUpdate(rel, &oldtup->t_self, newtup);
338 :
339 260 : InvokeObjectPostAlterHook(classId, objectId, 0);
340 :
341 : /* Do post catalog-update tasks */
342 260 : if (classId == PublicationRelationId)
343 : {
344 36 : 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 36 : InvalidatePubRelSyncCache(pub->oid, pub->puballtables);
355 : }
356 :
357 : /* Release memory */
358 260 : pfree(values);
359 260 : pfree(nulls);
360 260 : pfree(replaces);
361 260 : heap_freetuple(newtup);
362 :
363 260 : ReleaseSysCache(oldtup);
364 260 : }
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 1536 : ExecRenameStmt(RenameStmt *stmt)
374 : {
375 1536 : switch (stmt->renameType)
376 : {
377 84 : case OBJECT_TABCONSTRAINT:
378 : case OBJECT_DOMCONSTRAINT:
379 84 : return RenameConstraint(stmt);
380 :
381 6 : case OBJECT_DATABASE:
382 6 : return RenameDatabase(stmt->subname, stmt->newname);
383 :
384 30 : case OBJECT_ROLE:
385 30 : return RenameRole(stmt->subname, stmt->newname);
386 :
387 20 : case OBJECT_SCHEMA:
388 20 : return RenameSchema(stmt->subname, stmt->newname);
389 :
390 6 : case OBJECT_TABLESPACE:
391 6 : return RenameTableSpace(stmt->subname, stmt->newname);
392 :
393 510 : 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 510 : return RenameRelation(stmt);
400 :
401 316 : case OBJECT_COLUMN:
402 : case OBJECT_ATTRIBUTE:
403 316 : return renameatt(stmt);
404 :
405 34 : case OBJECT_RULE:
406 34 : return RenameRewriteRule(stmt->relation, stmt->subname,
407 34 : stmt->newname);
408 :
409 40 : case OBJECT_TRIGGER:
410 40 : return renametrig(stmt);
411 :
412 18 : case OBJECT_POLICY:
413 18 : return rename_policy(stmt);
414 :
415 32 : case OBJECT_DOMAIN:
416 : case OBJECT_TYPE:
417 32 : return RenameType(stmt);
418 :
419 440 : 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 440 : address = get_object_address(stmt->renameType,
443 : stmt->object,
444 : NULL,
445 : AccessExclusiveLock, false);
446 :
447 428 : catalog = table_open(address.classId, RowExclusiveLock);
448 428 : AlterObjectRename_internal(catalog,
449 : address.objectId,
450 428 : stmt->newname);
451 260 : table_close(catalog, RowExclusiveLock);
452 :
453 260 : return address;
454 : }
455 :
456 0 : default:
457 0 : 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 46 : ExecAlterObjectDependsStmt(AlterObjectDependsStmt *stmt, ObjectAddress *refAddress)
472 : {
473 : ObjectAddress address;
474 : ObjectAddress refAddr;
475 : Relation rel;
476 :
477 : address =
478 46 : 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 46 : 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 46 : if (rel)
497 34 : table_close(rel, NoLock);
498 :
499 46 : refAddr = get_object_address(OBJECT_EXTENSION, (Node *) stmt->extname,
500 : NULL, AccessExclusiveLock, false);
501 46 : if (refAddress)
502 46 : *refAddress = refAddr;
503 :
504 46 : if (stmt->remove)
505 : {
506 8 : 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 38 : currexts = getAutoExtensionsOfObject(address.classId,
516 : address.objectId);
517 38 : if (!list_member_oid(currexts, refAddr.objectId))
518 36 : recordDependencyOn(&address, &refAddr, DEPENDENCY_AUTO_EXTENSION);
519 : }
520 :
521 46 : 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 398 : ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *stmt,
535 : ObjectAddress *oldSchemaAddr)
536 : {
537 : ObjectAddress address;
538 : Oid oldNspOid;
539 :
540 398 : switch (stmt->objectType)
541 : {
542 12 : case OBJECT_EXTENSION:
543 12 : address = AlterExtensionNamespace(strVal(stmt->object), stmt->newschema,
544 : oldSchemaAddr ? &oldNspOid : NULL);
545 8 : break;
546 :
547 104 : case OBJECT_FOREIGN_TABLE:
548 : case OBJECT_SEQUENCE:
549 : case OBJECT_TABLE:
550 : case OBJECT_VIEW:
551 : case OBJECT_MATVIEW:
552 104 : address = AlterTableNamespace(stmt,
553 : oldSchemaAddr ? &oldNspOid : NULL);
554 96 : break;
555 :
556 18 : case OBJECT_DOMAIN:
557 : case OBJECT_TYPE:
558 18 : address = AlterTypeNamespace(castNode(List, stmt->object), stmt->newschema,
559 : stmt->objectType,
560 : oldSchemaAddr ? &oldNspOid : NULL);
561 18 : break;
562 :
563 : /* generic code path */
564 264 : 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 264 : address = get_object_address(stmt->objectType,
584 : stmt->object,
585 : NULL,
586 : AccessExclusiveLock,
587 : false);
588 258 : classId = address.classId;
589 258 : catalog = table_open(classId, RowExclusiveLock);
590 258 : nspOid = LookupCreationNamespace(stmt->newschema);
591 :
592 258 : oldNspOid = AlterObjectNamespace_internal(catalog, address.objectId,
593 : nspOid);
594 144 : table_close(catalog, RowExclusiveLock);
595 : }
596 144 : break;
597 :
598 0 : default:
599 0 : elog(ERROR, "unrecognized AlterObjectSchemaStmt type: %d",
600 : (int) stmt->objectType);
601 : return InvalidObjectAddress; /* keep compiler happy */
602 : }
603 :
604 266 : if (oldSchemaAddr)
605 266 : ObjectAddressSet(*oldSchemaAddr, NamespaceRelationId, oldNspOid);
606 :
607 266 : 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 42 : AlterObjectNamespace_oid(Oid classId, Oid objid, Oid nspOid,
626 : ObjectAddresses *objsMoved)
627 : {
628 42 : Oid oldNspOid = InvalidOid;
629 :
630 42 : switch (classId)
631 : {
632 2 : case RelationRelationId:
633 : {
634 : Relation rel;
635 :
636 2 : rel = relation_open(objid, AccessExclusiveLock);
637 2 : oldNspOid = RelationGetNamespace(rel);
638 :
639 2 : AlterTableNamespaceInternal(rel, oldNspOid, nspOid, objsMoved);
640 :
641 2 : relation_close(rel, NoLock);
642 2 : break;
643 : }
644 :
645 16 : case TypeRelationId:
646 16 : oldNspOid = AlterTypeNamespace_oid(objid, nspOid, true, objsMoved);
647 16 : break;
648 :
649 22 : 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 22 : catalog = table_open(classId, RowExclusiveLock);
664 :
665 22 : oldNspOid = AlterObjectNamespace_internal(catalog, objid,
666 : nspOid);
667 :
668 22 : table_close(catalog, RowExclusiveLock);
669 : }
670 22 : break;
671 :
672 42 : default:
673 : /* ignore object types that don't have schema-qualified names */
674 : Assert(get_object_attnum_namespace(classId) == InvalidAttrNumber);
675 : }
676 :
677 42 : 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 280 : AlterObjectNamespace_internal(Relation rel, Oid objid, Oid nspOid)
693 : {
694 280 : Oid classId = RelationGetRelid(rel);
695 280 : int oidCacheId = get_object_catcache_oid(classId);
696 280 : int nameCacheId = get_object_catcache_name(classId);
697 280 : AttrNumber Anum_name = get_object_attnum_name(classId);
698 280 : AttrNumber Anum_namespace = get_object_attnum_namespace(classId);
699 280 : 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 280 : tup = SearchSysCacheCopy1(oidCacheId, ObjectIdGetDatum(objid));
711 280 : if (!HeapTupleIsValid(tup)) /* should not happen */
712 0 : elog(ERROR, "cache lookup failed for object %u of catalog \"%s\"",
713 : objid, RelationGetRelationName(rel));
714 :
715 280 : name = heap_getattr(tup, Anum_name, RelationGetDescr(rel), &isnull);
716 : Assert(!isnull);
717 280 : namespace = heap_getattr(tup, Anum_namespace, RelationGetDescr(rel),
718 : &isnull);
719 : Assert(!isnull);
720 280 : 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 280 : if (oldNspOid == nspOid)
727 : {
728 6 : InvokeObjectPostAlterHook(classId, objid, 0);
729 6 : return oldNspOid;
730 : }
731 :
732 : /* Check basic namespace related issues */
733 274 : CheckSetNamespace(oldNspOid, nspOid);
734 :
735 : /* Permission checks ... superusers can always do it */
736 274 : if (!superuser())
737 : {
738 : Datum owner;
739 : Oid ownerId;
740 : AclResult aclresult;
741 :
742 : /* Fail if object does not have an explicit owner */
743 156 : if (Anum_owner <= 0)
744 0 : 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 156 : owner = heap_getattr(tup, Anum_owner, RelationGetDescr(rel), &isnull);
751 : Assert(!isnull);
752 156 : ownerId = DatumGetObjectId(owner);
753 :
754 156 : if (!has_privs_of_role(GetUserId(), ownerId))
755 54 : aclcheck_error(ACLCHECK_NOT_OWNER, get_object_type(classId, objid),
756 54 : NameStr(*(DatumGetName(name))));
757 :
758 : /* User must have CREATE privilege on new namespace */
759 102 : aclresult = object_aclcheck(NamespaceRelationId, nspOid, GetUserId(), ACL_CREATE);
760 102 : if (aclresult != ACLCHECK_OK)
761 0 : aclcheck_error(aclresult, OBJECT_SCHEMA,
762 0 : 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 220 : if (classId == ProcedureRelationId)
771 : {
772 64 : Form_pg_proc proc = (Form_pg_proc) GETSTRUCT(tup);
773 :
774 64 : IsThereFunctionInNamespace(NameStr(proc->proname), proc->pronargs,
775 : &proc->proargtypes, nspOid);
776 : }
777 156 : else if (classId == CollationRelationId)
778 : {
779 6 : Form_pg_collation coll = (Form_pg_collation) GETSTRUCT(tup);
780 :
781 6 : IsThereCollationInNamespace(NameStr(coll->collname), nspOid);
782 : }
783 150 : else if (classId == OperatorClassRelationId)
784 : {
785 18 : Form_pg_opclass opc = (Form_pg_opclass) GETSTRUCT(tup);
786 :
787 18 : IsThereOpClassInNamespace(NameStr(opc->opcname),
788 : opc->opcmethod, nspOid);
789 : }
790 132 : else if (classId == OperatorFamilyRelationId)
791 : {
792 18 : Form_pg_opfamily opf = (Form_pg_opfamily) GETSTRUCT(tup);
793 :
794 18 : IsThereOpFamilyInNamespace(NameStr(opf->opfname),
795 : opf->opfmethod, nspOid);
796 : }
797 216 : else if (nameCacheId >= 0 &&
798 102 : SearchSysCacheExists2(nameCacheId, name,
799 : ObjectIdGetDatum(nspOid)))
800 36 : report_namespace_conflict(classId,
801 36 : NameStr(*(DatumGetName(name))),
802 : nspOid);
803 :
804 : /* Build modified tuple */
805 160 : values = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(Datum));
806 160 : nulls = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool));
807 160 : replaces = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool));
808 160 : values[Anum_namespace - 1] = ObjectIdGetDatum(nspOid);
809 160 : replaces[Anum_namespace - 1] = true;
810 160 : newtup = heap_modify_tuple(tup, RelationGetDescr(rel),
811 : values, nulls, replaces);
812 :
813 : /* Perform actual update */
814 160 : CatalogTupleUpdate(rel, &tup->t_self, newtup);
815 :
816 : /* Release memory */
817 160 : pfree(values);
818 160 : pfree(nulls);
819 160 : pfree(replaces);
820 :
821 : /* update dependency to point to the new schema */
822 160 : if (changeDependencyFor(classId, objid,
823 : NamespaceRelationId, oldNspOid, nspOid) != 1)
824 0 : elog(ERROR, "could not change schema dependency for object %u",
825 : objid);
826 :
827 160 : InvokeObjectPostAlterHook(classId, objid, 0);
828 :
829 160 : 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 1626 : ExecAlterOwnerStmt(AlterOwnerStmt *stmt)
838 : {
839 1626 : Oid newowner = get_rolespec_oid(stmt->newowner, false);
840 :
841 1614 : switch (stmt->objectType)
842 : {
843 78 : case OBJECT_DATABASE:
844 78 : return AlterDatabaseOwner(strVal(stmt->object), newowner);
845 :
846 56 : case OBJECT_SCHEMA:
847 56 : return AlterSchemaOwner(strVal(stmt->object), newowner);
848 :
849 126 : case OBJECT_TYPE:
850 : case OBJECT_DOMAIN: /* same as TYPE */
851 126 : return AlterTypeOwner(castNode(List, stmt->object), newowner, stmt->objectType);
852 : break;
853 :
854 20 : case OBJECT_FDW:
855 20 : return AlterForeignDataWrapperOwner(strVal(stmt->object),
856 : newowner);
857 :
858 68 : case OBJECT_FOREIGN_SERVER:
859 68 : return AlterForeignServerOwner(strVal(stmt->object),
860 : newowner);
861 :
862 14 : case OBJECT_EVENT_TRIGGER:
863 14 : return AlterEventTriggerOwner(strVal(stmt->object),
864 : newowner);
865 :
866 26 : case OBJECT_PUBLICATION:
867 26 : return AlterPublicationOwner(strVal(stmt->object),
868 : newowner);
869 :
870 18 : case OBJECT_SUBSCRIPTION:
871 18 : return AlterSubscriptionOwner(strVal(stmt->object),
872 : newowner);
873 :
874 : /* Generic cases */
875 1208 : 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 1208 : address = get_object_address(stmt->objectType,
894 : stmt->object,
895 : NULL,
896 : AccessExclusiveLock,
897 : false);
898 :
899 1200 : AlterObjectOwner_internal(address.classId, address.objectId,
900 : newowner);
901 :
902 1026 : return address;
903 : }
904 : break;
905 :
906 0 : default:
907 0 : 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 1220 : AlterObjectOwner_internal(Oid classId, Oid objectId, Oid new_ownerId)
927 : {
928 : /* For large objects, the catalog to modify is pg_largeobject_metadata */
929 1220 : Oid catalogId = (classId == LargeObjectRelationId) ? LargeObjectMetadataRelationId : classId;
930 1220 : AttrNumber Anum_oid = get_object_attnum_oid(catalogId);
931 1220 : AttrNumber Anum_owner = get_object_attnum_owner(catalogId);
932 1220 : AttrNumber Anum_namespace = get_object_attnum_namespace(catalogId);
933 1220 : AttrNumber Anum_acl = get_object_attnum_acl(catalogId);
934 1220 : 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 1220 : Oid namespaceId = InvalidOid;
941 :
942 1220 : rel = table_open(catalogId, RowExclusiveLock);
943 :
944 : /* Search tuple and lock it. */
945 : oldtup =
946 1220 : get_catalog_object_by_oid_extended(rel, Anum_oid, objectId, true);
947 1220 : if (oldtup == NULL)
948 0 : elog(ERROR, "cache lookup failed for object %u of catalog \"%s\"",
949 : objectId, RelationGetRelationName(rel));
950 :
951 1220 : datum = heap_getattr(oldtup, Anum_owner,
952 : RelationGetDescr(rel), &isnull);
953 : Assert(!isnull);
954 1220 : old_ownerId = DatumGetObjectId(datum);
955 :
956 1220 : if (Anum_namespace != InvalidAttrNumber)
957 : {
958 1062 : datum = heap_getattr(oldtup, Anum_namespace,
959 : RelationGetDescr(rel), &isnull);
960 : Assert(!isnull);
961 1062 : namespaceId = DatumGetObjectId(datum);
962 : }
963 :
964 1220 : 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 378 : if (!superuser())
974 : {
975 : /* must be owner */
976 234 : if (!has_privs_of_role(GetUserId(), old_ownerId))
977 : {
978 : char *objname;
979 : char namebuf[NAMEDATALEN];
980 :
981 60 : if (Anum_name != InvalidAttrNumber)
982 : {
983 60 : datum = heap_getattr(oldtup, Anum_name,
984 : RelationGetDescr(rel), &isnull);
985 : Assert(!isnull);
986 60 : objname = NameStr(*DatumGetName(datum));
987 : }
988 : else
989 : {
990 0 : snprintf(namebuf, sizeof(namebuf), "%u", objectId);
991 0 : objname = namebuf;
992 : }
993 60 : aclcheck_error(ACLCHECK_NOT_OWNER,
994 : get_object_type(catalogId, objectId),
995 : objname);
996 : }
997 : /* Must be able to become new owner */
998 174 : check_can_set_role(GetUserId(), new_ownerId);
999 :
1000 : /* New owner must have CREATE privilege on namespace */
1001 60 : if (OidIsValid(namespaceId))
1002 : {
1003 : AclResult aclresult;
1004 :
1005 54 : aclresult = object_aclcheck(NamespaceRelationId, namespaceId, new_ownerId,
1006 : ACL_CREATE);
1007 54 : if (aclresult != ACLCHECK_OK)
1008 0 : aclcheck_error(aclresult, OBJECT_SCHEMA,
1009 0 : get_namespace_name(namespaceId));
1010 : }
1011 : }
1012 :
1013 : /* Build a modified tuple */
1014 204 : nattrs = RelationGetNumberOfAttributes(rel);
1015 204 : values = palloc0(nattrs * sizeof(Datum));
1016 204 : nulls = palloc0(nattrs * sizeof(bool));
1017 204 : replaces = palloc0(nattrs * sizeof(bool));
1018 204 : values[Anum_owner - 1] = ObjectIdGetDatum(new_ownerId);
1019 204 : 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 204 : if (Anum_acl != InvalidAttrNumber)
1026 : {
1027 106 : datum = heap_getattr(oldtup,
1028 : Anum_acl, RelationGetDescr(rel), &isnull);
1029 106 : if (!isnull)
1030 : {
1031 : Acl *newAcl;
1032 :
1033 8 : newAcl = aclnewowner(DatumGetAclP(datum),
1034 : old_ownerId, new_ownerId);
1035 8 : values[Anum_acl - 1] = PointerGetDatum(newAcl);
1036 8 : replaces[Anum_acl - 1] = true;
1037 : }
1038 : }
1039 :
1040 204 : newtup = heap_modify_tuple(oldtup, RelationGetDescr(rel),
1041 : values, nulls, replaces);
1042 :
1043 : /* Perform actual update */
1044 204 : CatalogTupleUpdate(rel, &newtup->t_self, newtup);
1045 :
1046 204 : UnlockTuple(rel, &oldtup->t_self, InplaceUpdateTupleLock);
1047 :
1048 : /* Update owner dependency reference */
1049 204 : changeDependencyOnOwner(classId, objectId, new_ownerId);
1050 :
1051 : /* Release memory */
1052 204 : pfree(values);
1053 204 : pfree(nulls);
1054 204 : pfree(replaces);
1055 : }
1056 : else
1057 842 : UnlockTuple(rel, &oldtup->t_self, InplaceUpdateTupleLock);
1058 :
1059 : /* Note the post-alter hook gets classId not catalogId */
1060 1046 : InvokeObjectPostAlterHook(classId, objectId, 0);
1061 :
1062 1046 : table_close(rel, RowExclusiveLock);
1063 1046 : }
|
