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