PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
alter.h File Reference
Include dependency graph for alter.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

ObjectAddress ExecRenameStmt (RenameStmt *stmt)
 
ObjectAddress ExecAlterObjectDependsStmt (AlterObjectDependsStmt *stmt, ObjectAddress *refAddress)
 
ObjectAddress ExecAlterObjectSchemaStmt (AlterObjectSchemaStmt *stmt, ObjectAddress *oldSchemaAddr)
 
Oid AlterObjectNamespace_oid (Oid classId, Oid objid, Oid nspOid, ObjectAddresses *objsMoved)
 
ObjectAddress ExecAlterOwnerStmt (AlterOwnerStmt *stmt)
 
void AlterObjectOwner_internal (Oid classId, Oid objectId, Oid new_ownerId)
 

Function Documentation

◆ AlterObjectNamespace_oid()

Oid AlterObjectNamespace_oid ( Oid  classId,
Oid  objid,
Oid  nspOid,
ObjectAddresses objsMoved 
)

Definition at line 609 of file alter.c.

611{
612 Oid oldNspOid = InvalidOid;
613
614 switch (classId)
615 {
616 case RelationRelationId:
617 {
618 Relation rel;
619
621 oldNspOid = RelationGetNamespace(rel);
622
623 AlterTableNamespaceInternal(rel, oldNspOid, nspOid, objsMoved);
624
626 break;
627 }
628
629 case TypeRelationId:
630 oldNspOid = AlterTypeNamespace_oid(objid, nspOid, true, objsMoved);
631 break;
632
633 case ProcedureRelationId:
634 case CollationRelationId:
635 case ConversionRelationId:
636 case OperatorRelationId:
637 case OperatorClassRelationId:
638 case OperatorFamilyRelationId:
639 case StatisticExtRelationId:
640 case TSParserRelationId:
641 case TSDictionaryRelationId:
642 case TSTemplateRelationId:
643 case TSConfigRelationId:
644 {
645 Relation catalog;
646
647 catalog = table_open(classId, RowExclusiveLock);
648
649 oldNspOid = AlterObjectNamespace_internal(catalog, objid,
650 nspOid);
651
653 }
654 break;
655
656 default:
657 /* ignore object types that don't have schema-qualified names */
659 }
660
661 return oldNspOid;
662}
static Oid AlterObjectNamespace_internal(Relation rel, Oid objid, Oid nspOid)
Definition: alter.c:676
#define InvalidAttrNumber
Definition: attnum.h:23
#define Assert(condition)
Definition: c.h:812
#define NoLock
Definition: lockdefs.h:34
#define AccessExclusiveLock
Definition: lockdefs.h:43
#define RowExclusiveLock
Definition: lockdefs.h:38
AttrNumber get_object_attnum_namespace(Oid class_id)
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
#define RelationGetNamespace(relation)
Definition: rel.h:546
void relation_close(Relation relation, LOCKMODE lockmode)
Definition: relation.c:205
Relation relation_open(Oid relationId, LOCKMODE lockmode)
Definition: relation.c:47
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40
void AlterTableNamespaceInternal(Relation rel, Oid oldNspOid, Oid nspOid, ObjectAddresses *objsMoved)
Definition: tablecmds.c:17784
Oid AlterTypeNamespace_oid(Oid typeOid, Oid nspOid, bool ignoreDependent, ObjectAddresses *objsMoved)
Definition: typecmds.c:4124

References AccessExclusiveLock, AlterObjectNamespace_internal(), AlterTableNamespaceInternal(), AlterTypeNamespace_oid(), Assert, get_object_attnum_namespace(), InvalidAttrNumber, InvalidOid, NoLock, relation_close(), relation_open(), RelationGetNamespace, RowExclusiveLock, table_close(), and table_open().

Referenced by AlterExtensionNamespace().

◆ AlterObjectOwner_internal()

void AlterObjectOwner_internal ( Oid  classId,
Oid  objectId,
Oid  new_ownerId 
)

Definition at line 910 of file alter.c.

911{
912 /* For large objects, the catalog to modify is pg_largeobject_metadata */
913 Oid catalogId = (classId == LargeObjectRelationId) ? LargeObjectMetadataRelationId : classId;
914 AttrNumber Anum_oid = get_object_attnum_oid(catalogId);
915 AttrNumber Anum_owner = get_object_attnum_owner(catalogId);
916 AttrNumber Anum_namespace = get_object_attnum_namespace(catalogId);
917 AttrNumber Anum_acl = get_object_attnum_acl(catalogId);
918 AttrNumber Anum_name = get_object_attnum_name(catalogId);
919 Relation rel;
920 HeapTuple oldtup;
921 Datum datum;
922 bool isnull;
923 Oid old_ownerId;
924 Oid namespaceId = InvalidOid;
925
926 rel = table_open(catalogId, RowExclusiveLock);
927
928 /* Search tuple and lock it. */
929 oldtup =
930 get_catalog_object_by_oid_extended(rel, Anum_oid, objectId, true);
931 if (oldtup == NULL)
932 elog(ERROR, "cache lookup failed for object %u of catalog \"%s\"",
933 objectId, RelationGetRelationName(rel));
934
935 datum = heap_getattr(oldtup, Anum_owner,
936 RelationGetDescr(rel), &isnull);
937 Assert(!isnull);
938 old_ownerId = DatumGetObjectId(datum);
939
940 if (Anum_namespace != InvalidAttrNumber)
941 {
942 datum = heap_getattr(oldtup, Anum_namespace,
943 RelationGetDescr(rel), &isnull);
944 Assert(!isnull);
945 namespaceId = DatumGetObjectId(datum);
946 }
947
948 if (old_ownerId != new_ownerId)
949 {
950 AttrNumber nattrs;
951 HeapTuple newtup;
952 Datum *values;
953 bool *nulls;
954 bool *replaces;
955
956 /* Superusers can bypass permission checks */
957 if (!superuser())
958 {
959 /* must be owner */
960 if (!has_privs_of_role(GetUserId(), old_ownerId))
961 {
962 char *objname;
963 char namebuf[NAMEDATALEN];
964
965 if (Anum_name != InvalidAttrNumber)
966 {
967 datum = heap_getattr(oldtup, Anum_name,
968 RelationGetDescr(rel), &isnull);
969 Assert(!isnull);
970 objname = NameStr(*DatumGetName(datum));
971 }
972 else
973 {
974 snprintf(namebuf, sizeof(namebuf), "%u", objectId);
975 objname = namebuf;
976 }
978 get_object_type(catalogId, objectId),
979 objname);
980 }
981 /* Must be able to become new owner */
982 check_can_set_role(GetUserId(), new_ownerId);
983
984 /* New owner must have CREATE privilege on namespace */
985 if (OidIsValid(namespaceId))
986 {
987 AclResult aclresult;
988
989 aclresult = object_aclcheck(NamespaceRelationId, namespaceId, new_ownerId,
990 ACL_CREATE);
991 if (aclresult != ACLCHECK_OK)
992 aclcheck_error(aclresult, OBJECT_SCHEMA,
993 get_namespace_name(namespaceId));
994 }
995 }
996
997 /* Build a modified tuple */
998 nattrs = RelationGetNumberOfAttributes(rel);
999 values = palloc0(nattrs * sizeof(Datum));
1000 nulls = palloc0(nattrs * sizeof(bool));
1001 replaces = palloc0(nattrs * sizeof(bool));
1002 values[Anum_owner - 1] = ObjectIdGetDatum(new_ownerId);
1003 replaces[Anum_owner - 1] = true;
1004
1005 /*
1006 * Determine the modified ACL for the new owner. This is only
1007 * necessary when the ACL is non-null.
1008 */
1009 if (Anum_acl != InvalidAttrNumber)
1010 {
1011 datum = heap_getattr(oldtup,
1012 Anum_acl, RelationGetDescr(rel), &isnull);
1013 if (!isnull)
1014 {
1015 Acl *newAcl;
1016
1017 newAcl = aclnewowner(DatumGetAclP(datum),
1018 old_ownerId, new_ownerId);
1019 values[Anum_acl - 1] = PointerGetDatum(newAcl);
1020 replaces[Anum_acl - 1] = true;
1021 }
1022 }
1023
1024 newtup = heap_modify_tuple(oldtup, RelationGetDescr(rel),
1025 values, nulls, replaces);
1026
1027 /* Perform actual update */
1028 CatalogTupleUpdate(rel, &newtup->t_self, newtup);
1029
1031
1032 /* Update owner dependency reference */
1033 changeDependencyOnOwner(classId, objectId, new_ownerId);
1034
1035 /* Release memory */
1036 pfree(values);
1037 pfree(nulls);
1038 pfree(replaces);
1039 }
1040 else
1042
1043 /* Note the post-alter hook gets classId not catalogId */
1044 InvokeObjectPostAlterHook(classId, objectId, 0);
1045
1047}
bool has_privs_of_role(Oid member, Oid role)
Definition: acl.c:5268
Acl * aclnewowner(const Acl *old_acl, Oid oldOwnerId, Oid newOwnerId)
Definition: acl.c:1103
void check_can_set_role(Oid member, Oid role)
Definition: acl.c:5325
AclResult
Definition: acl.h:182
@ ACLCHECK_OK
Definition: acl.h:183
@ ACLCHECK_NOT_OWNER
Definition: acl.h:185
#define DatumGetAclP(X)
Definition: acl.h:120
void aclcheck_error(AclResult aclerr, ObjectType objtype, const char *objectname)
Definition: aclchk.c:2622
AclResult object_aclcheck(Oid classid, Oid objectid, Oid roleid, AclMode mode)
Definition: aclchk.c:3810
int16 AttrNumber
Definition: attnum.h:21
static Datum values[MAXATTR]
Definition: bootstrap.c:151
#define NameStr(name)
Definition: c.h:700
#define OidIsValid(objectId)
Definition: c.h:729
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
HeapTuple heap_modify_tuple(HeapTuple tuple, TupleDesc tupleDesc, const Datum *replValues, const bool *replIsnull, const bool *doReplace)
Definition: heaptuple.c:1210
static Datum heap_getattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
Definition: htup_details.h:792
void CatalogTupleUpdate(Relation heapRel, ItemPointer otid, HeapTuple tup)
Definition: indexing.c:313
void UnlockTuple(Relation relation, ItemPointer tid, LOCKMODE lockmode)
Definition: lmgr.c:594
#define InplaceUpdateTupleLock
Definition: lockdefs.h:48
char * get_namespace_name(Oid nspid)
Definition: lsyscache.c:3366
void pfree(void *pointer)
Definition: mcxt.c:1521
void * palloc0(Size size)
Definition: mcxt.c:1347
Oid GetUserId(void)
Definition: miscinit.c:517
#define InvokeObjectPostAlterHook(classId, objectId, subId)
Definition: objectaccess.h:197
AttrNumber get_object_attnum_owner(Oid class_id)
AttrNumber get_object_attnum_oid(Oid class_id)
AttrNumber get_object_attnum_name(Oid class_id)
AttrNumber get_object_attnum_acl(Oid class_id)
ObjectType get_object_type(Oid class_id, Oid object_id)
HeapTuple get_catalog_object_by_oid_extended(Relation catalog, AttrNumber oidcol, Oid objectId, bool locktup)
@ OBJECT_SCHEMA
Definition: parsenodes.h:2304
#define ACL_CREATE
Definition: parsenodes.h:85
#define NAMEDATALEN
void changeDependencyOnOwner(Oid classId, Oid objectId, Oid newOwnerId)
Definition: pg_shdepend.c:316
#define snprintf
Definition: port.h:238
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
static Name DatumGetName(Datum X)
Definition: postgres.h:360
uintptr_t Datum
Definition: postgres.h:64
static Oid DatumGetObjectId(Datum X)
Definition: postgres.h:242
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
#define RelationGetDescr(relation)
Definition: rel.h:531
#define RelationGetNumberOfAttributes(relation)
Definition: rel.h:511
#define RelationGetRelationName(relation)
Definition: rel.h:539
ItemPointerData t_self
Definition: htup.h:65
bool superuser(void)
Definition: superuser.c:46

References ACL_CREATE, aclcheck_error(), ACLCHECK_NOT_OWNER, ACLCHECK_OK, aclnewowner(), Assert, CatalogTupleUpdate(), changeDependencyOnOwner(), check_can_set_role(), DatumGetAclP, DatumGetName(), DatumGetObjectId(), elog, ERROR, get_catalog_object_by_oid_extended(), get_namespace_name(), get_object_attnum_acl(), get_object_attnum_name(), get_object_attnum_namespace(), get_object_attnum_oid(), get_object_attnum_owner(), get_object_type(), GetUserId(), has_privs_of_role(), heap_getattr(), heap_modify_tuple(), InplaceUpdateTupleLock, InvalidAttrNumber, InvalidOid, InvokeObjectPostAlterHook, NAMEDATALEN, NameStr, object_aclcheck(), OBJECT_SCHEMA, ObjectIdGetDatum(), OidIsValid, palloc0(), pfree(), PointerGetDatum(), RelationGetDescr, RelationGetNumberOfAttributes, RelationGetRelationName, RowExclusiveLock, snprintf, superuser(), HeapTupleData::t_self, table_close(), table_open(), UnlockTuple(), and values.

Referenced by ExecAlterOwnerStmt(), and shdepReassignOwned_Owner().

◆ ExecAlterObjectDependsStmt()

ObjectAddress ExecAlterObjectDependsStmt ( AlterObjectDependsStmt stmt,
ObjectAddress refAddress 
)

Definition at line 455 of file alter.c.

456{
457 ObjectAddress address;
458 ObjectAddress refAddr;
459 Relation rel;
460
461 address =
462 get_object_address_rv(stmt->objectType, stmt->relation, (List *) stmt->object,
463 &rel, AccessExclusiveLock, false);
464
465 /*
466 * Verify that the user is entitled to run the command.
467 *
468 * We don't check any privileges on the extension, because that's not
469 * needed. The object owner is stipulating, by running this command, that
470 * the extension owner can drop the object whenever they feel like it,
471 * which is not considered a problem.
472 */
474 stmt->objectType, address, stmt->object, rel);
475
476 /*
477 * If a relation was involved, it would have been opened and locked. We
478 * don't need the relation here, but we'll retain the lock until commit.
479 */
480 if (rel)
481 table_close(rel, NoLock);
482
483 refAddr = get_object_address(OBJECT_EXTENSION, (Node *) stmt->extname,
484 NULL, AccessExclusiveLock, false);
485 if (refAddress)
486 *refAddress = refAddr;
487
488 if (stmt->remove)
489 {
492 refAddr.classId, refAddr.objectId);
493 }
494 else
495 {
496 List *currexts;
497
498 /* Avoid duplicates */
499 currexts = getAutoExtensionsOfObject(address.classId,
500 address.objectId);
501 if (!list_member_oid(currexts, refAddr.objectId))
503 }
504
505 return address;
506}
@ DEPENDENCY_AUTO_EXTENSION
Definition: dependency.h:39
#define stmt
Definition: indent_codes.h:59
bool list_member_oid(const List *list, Oid datum)
Definition: list.c:722
ObjectAddress get_object_address_rv(ObjectType objtype, RangeVar *rel, List *object, Relation *relp, LOCKMODE lockmode, bool missing_ok)
void check_object_ownership(Oid roleid, ObjectType objtype, ObjectAddress address, Node *object, Relation relation)
ObjectAddress get_object_address(ObjectType objtype, Node *object, Relation *relp, LOCKMODE lockmode, bool missing_ok)
@ OBJECT_EXTENSION
Definition: parsenodes.h:2283
void recordDependencyOn(const ObjectAddress *depender, const ObjectAddress *referenced, DependencyType behavior)
Definition: pg_depend.c:45
long deleteDependencyRecordsForSpecific(Oid classId, Oid objectId, char deptype, Oid refclassId, Oid refobjectId)
Definition: pg_depend.c:398
List * getAutoExtensionsOfObject(Oid classId, Oid objectId)
Definition: pg_depend.c:778
Definition: pg_list.h:54
Definition: nodes.h:129

References AccessExclusiveLock, check_object_ownership(), ObjectAddress::classId, deleteDependencyRecordsForSpecific(), DEPENDENCY_AUTO_EXTENSION, get_object_address(), get_object_address_rv(), getAutoExtensionsOfObject(), GetUserId(), list_member_oid(), NoLock, OBJECT_EXTENSION, ObjectAddress::objectId, recordDependencyOn(), stmt, and table_close().

Referenced by ProcessUtilitySlow(), and standard_ProcessUtility().

◆ ExecAlterObjectSchemaStmt()

ObjectAddress ExecAlterObjectSchemaStmt ( AlterObjectSchemaStmt stmt,
ObjectAddress oldSchemaAddr 
)

Definition at line 518 of file alter.c.

520{
521 ObjectAddress address;
522 Oid oldNspOid;
523
524 switch (stmt->objectType)
525 {
526 case OBJECT_EXTENSION:
527 address = AlterExtensionNamespace(strVal(stmt->object), stmt->newschema,
528 oldSchemaAddr ? &oldNspOid : NULL);
529 break;
530
532 case OBJECT_SEQUENCE:
533 case OBJECT_TABLE:
534 case OBJECT_VIEW:
535 case OBJECT_MATVIEW:
536 address = AlterTableNamespace(stmt,
537 oldSchemaAddr ? &oldNspOid : NULL);
538 break;
539
540 case OBJECT_DOMAIN:
541 case OBJECT_TYPE:
542 address = AlterTypeNamespace(castNode(List, stmt->object), stmt->newschema,
543 stmt->objectType,
544 oldSchemaAddr ? &oldNspOid : NULL);
545 break;
546
547 /* generic code path */
548 case OBJECT_AGGREGATE:
549 case OBJECT_COLLATION:
551 case OBJECT_FUNCTION:
552 case OBJECT_OPERATOR:
553 case OBJECT_OPCLASS:
554 case OBJECT_OPFAMILY:
555 case OBJECT_PROCEDURE:
556 case OBJECT_ROUTINE:
560 case OBJECT_TSPARSER:
562 {
563 Relation catalog;
564 Oid classId;
565 Oid nspOid;
566
567 address = get_object_address(stmt->objectType,
568 stmt->object,
569 NULL,
571 false);
572 classId = address.classId;
573 catalog = table_open(classId, RowExclusiveLock);
574 nspOid = LookupCreationNamespace(stmt->newschema);
575
576 oldNspOid = AlterObjectNamespace_internal(catalog, address.objectId,
577 nspOid);
579 }
580 break;
581
582 default:
583 elog(ERROR, "unrecognized AlterObjectSchemaStmt type: %d",
584 (int) stmt->objectType);
585 return InvalidObjectAddress; /* keep compiler happy */
586 }
587
588 if (oldSchemaAddr)
589 ObjectAddressSet(*oldSchemaAddr, NamespaceRelationId, oldNspOid);
590
591 return address;
592}
ObjectAddress AlterExtensionNamespace(const char *extensionName, const char *newschema, Oid *oldschema)
Definition: extension.c:2883
Oid LookupCreationNamespace(const char *nspname)
Definition: namespace.c:3428
#define castNode(_type_, nodeptr)
Definition: nodes.h:176
const ObjectAddress InvalidObjectAddress
#define ObjectAddressSet(addr, class_id, object_id)
Definition: objectaddress.h:40
@ OBJECT_TSPARSER
Definition: parsenodes.h:2315
@ OBJECT_COLLATION
Definition: parsenodes.h:2275
@ OBJECT_OPCLASS
Definition: parsenodes.h:2292
@ OBJECT_AGGREGATE
Definition: parsenodes.h:2269
@ OBJECT_MATVIEW
Definition: parsenodes.h:2291
@ OBJECT_OPERATOR
Definition: parsenodes.h:2293
@ OBJECT_FOREIGN_TABLE
Definition: parsenodes.h:2286
@ OBJECT_TSCONFIGURATION
Definition: parsenodes.h:2313
@ OBJECT_OPFAMILY
Definition: parsenodes.h:2294
@ OBJECT_DOMAIN
Definition: parsenodes.h:2280
@ OBJECT_ROUTINE
Definition: parsenodes.h:2302
@ OBJECT_PROCEDURE
Definition: parsenodes.h:2297
@ OBJECT_SEQUENCE
Definition: parsenodes.h:2305
@ OBJECT_TSTEMPLATE
Definition: parsenodes.h:2316
@ OBJECT_TSDICTIONARY
Definition: parsenodes.h:2314
@ OBJECT_CONVERSION
Definition: parsenodes.h:2276
@ OBJECT_TABLE
Definition: parsenodes.h:2309
@ OBJECT_VIEW
Definition: parsenodes.h:2319
@ OBJECT_TYPE
Definition: parsenodes.h:2317
@ OBJECT_FUNCTION
Definition: parsenodes.h:2287
@ OBJECT_STATISTIC_EXT
Definition: parsenodes.h:2307
ObjectAddress AlterTableNamespace(AlterObjectSchemaStmt *stmt, Oid *oldschema)
Definition: tablecmds.c:17713
ObjectAddress AlterTypeNamespace(List *names, const char *newschema, ObjectType objecttype, Oid *oldschema)
Definition: typecmds.c:4075
#define strVal(v)
Definition: value.h:82

References AccessExclusiveLock, AlterExtensionNamespace(), AlterObjectNamespace_internal(), AlterTableNamespace(), AlterTypeNamespace(), castNode, ObjectAddress::classId, elog, ERROR, get_object_address(), InvalidObjectAddress, LookupCreationNamespace(), OBJECT_AGGREGATE, OBJECT_COLLATION, OBJECT_CONVERSION, OBJECT_DOMAIN, OBJECT_EXTENSION, OBJECT_FOREIGN_TABLE, OBJECT_FUNCTION, OBJECT_MATVIEW, OBJECT_OPCLASS, OBJECT_OPERATOR, OBJECT_OPFAMILY, OBJECT_PROCEDURE, OBJECT_ROUTINE, OBJECT_SEQUENCE, OBJECT_STATISTIC_EXT, OBJECT_TABLE, OBJECT_TSCONFIGURATION, OBJECT_TSDICTIONARY, OBJECT_TSPARSER, OBJECT_TSTEMPLATE, OBJECT_TYPE, OBJECT_VIEW, ObjectAddressSet, ObjectAddress::objectId, RowExclusiveLock, stmt, strVal, table_close(), and table_open().

Referenced by ProcessUtilitySlow(), and standard_ProcessUtility().

◆ ExecAlterOwnerStmt()

ObjectAddress ExecAlterOwnerStmt ( AlterOwnerStmt stmt)

Definition at line 821 of file alter.c.

822{
823 Oid newowner = get_rolespec_oid(stmt->newowner, false);
824
825 switch (stmt->objectType)
826 {
827 case OBJECT_DATABASE:
828 return AlterDatabaseOwner(strVal(stmt->object), newowner);
829
830 case OBJECT_SCHEMA:
831 return AlterSchemaOwner(strVal(stmt->object), newowner);
832
833 case OBJECT_TYPE:
834 case OBJECT_DOMAIN: /* same as TYPE */
835 return AlterTypeOwner(castNode(List, stmt->object), newowner, stmt->objectType);
836 break;
837
838 case OBJECT_FDW:
840 newowner);
841
843 return AlterForeignServerOwner(strVal(stmt->object),
844 newowner);
845
847 return AlterEventTriggerOwner(strVal(stmt->object),
848 newowner);
849
851 return AlterPublicationOwner(strVal(stmt->object),
852 newowner);
853
855 return AlterSubscriptionOwner(strVal(stmt->object),
856 newowner);
857
858 /* Generic cases */
859 case OBJECT_AGGREGATE:
860 case OBJECT_COLLATION:
862 case OBJECT_FUNCTION:
863 case OBJECT_LANGUAGE:
865 case OBJECT_OPERATOR:
866 case OBJECT_OPCLASS:
867 case OBJECT_OPFAMILY:
868 case OBJECT_PROCEDURE:
869 case OBJECT_ROUTINE:
874 {
875 ObjectAddress address;
876
877 address = get_object_address(stmt->objectType,
878 stmt->object,
879 NULL,
881 false);
882
884 newowner);
885
886 return address;
887 }
888 break;
889
890 default:
891 elog(ERROR, "unrecognized AlterOwnerStmt type: %d",
892 (int) stmt->objectType);
893 return InvalidObjectAddress; /* keep compiler happy */
894 }
895}
Oid get_rolespec_oid(const RoleSpec *role, bool missing_ok)
Definition: acl.c:5588
void AlterObjectOwner_internal(Oid classId, Oid objectId, Oid new_ownerId)
Definition: alter.c:910
ObjectAddress AlterDatabaseOwner(const char *dbname, Oid newOwnerId)
Definition: dbcommands.c:2637
ObjectAddress AlterEventTriggerOwner(const char *name, Oid newOwnerId)
ObjectAddress AlterForeignServerOwner(const char *name, Oid newOwnerId)
Definition: foreigncmds.c:415
ObjectAddress AlterForeignDataWrapperOwner(const char *name, Oid newOwnerId)
Definition: foreigncmds.c:275
@ OBJECT_EVENT_TRIGGER
Definition: parsenodes.h:2282
@ OBJECT_FDW
Definition: parsenodes.h:2284
@ OBJECT_TABLESPACE
Definition: parsenodes.h:2310
@ OBJECT_LARGEOBJECT
Definition: parsenodes.h:2290
@ OBJECT_DATABASE
Definition: parsenodes.h:2277
@ OBJECT_LANGUAGE
Definition: parsenodes.h:2289
@ OBJECT_FOREIGN_SERVER
Definition: parsenodes.h:2285
@ OBJECT_PUBLICATION
Definition: parsenodes.h:2298
@ OBJECT_SUBSCRIPTION
Definition: parsenodes.h:2306
ObjectAddress AlterPublicationOwner(const char *name, Oid newOwnerId)
ObjectAddress AlterSchemaOwner(const char *name, Oid newOwnerId)
Definition: schemacmds.c:330
ObjectAddress AlterSubscriptionOwner(const char *name, Oid newOwnerId)
ObjectAddress AlterTypeOwner(List *names, Oid newOwnerId, ObjectType objecttype)
Definition: typecmds.c:3842

References AccessExclusiveLock, AlterDatabaseOwner(), AlterEventTriggerOwner(), AlterForeignDataWrapperOwner(), AlterForeignServerOwner(), AlterObjectOwner_internal(), AlterPublicationOwner(), AlterSchemaOwner(), AlterSubscriptionOwner(), AlterTypeOwner(), castNode, ObjectAddress::classId, elog, ERROR, get_object_address(), get_rolespec_oid(), InvalidObjectAddress, OBJECT_AGGREGATE, OBJECT_COLLATION, OBJECT_CONVERSION, OBJECT_DATABASE, OBJECT_DOMAIN, OBJECT_EVENT_TRIGGER, OBJECT_FDW, OBJECT_FOREIGN_SERVER, OBJECT_FUNCTION, OBJECT_LANGUAGE, OBJECT_LARGEOBJECT, OBJECT_OPCLASS, OBJECT_OPERATOR, OBJECT_OPFAMILY, OBJECT_PROCEDURE, OBJECT_PUBLICATION, OBJECT_ROUTINE, OBJECT_SCHEMA, OBJECT_STATISTIC_EXT, OBJECT_SUBSCRIPTION, OBJECT_TABLESPACE, OBJECT_TSCONFIGURATION, OBJECT_TSDICTIONARY, OBJECT_TYPE, ObjectAddress::objectId, stmt, and strVal.

Referenced by ProcessUtilitySlow(), and standard_ProcessUtility().

◆ ExecRenameStmt()

ObjectAddress ExecRenameStmt ( RenameStmt stmt)

Definition at line 357 of file alter.c.

358{
359 switch (stmt->renameType)
360 {
363 return RenameConstraint(stmt);
364
365 case OBJECT_DATABASE:
366 return RenameDatabase(stmt->subname, stmt->newname);
367
368 case OBJECT_ROLE:
369 return RenameRole(stmt->subname, stmt->newname);
370
371 case OBJECT_SCHEMA:
372 return RenameSchema(stmt->subname, stmt->newname);
373
375 return RenameTableSpace(stmt->subname, stmt->newname);
376
377 case OBJECT_TABLE:
378 case OBJECT_SEQUENCE:
379 case OBJECT_VIEW:
380 case OBJECT_MATVIEW:
381 case OBJECT_INDEX:
383 return RenameRelation(stmt);
384
385 case OBJECT_COLUMN:
386 case OBJECT_ATTRIBUTE:
387 return renameatt(stmt);
388
389 case OBJECT_RULE:
390 return RenameRewriteRule(stmt->relation, stmt->subname,
391 stmt->newname);
392
393 case OBJECT_TRIGGER:
394 return renametrig(stmt);
395
396 case OBJECT_POLICY:
397 return rename_policy(stmt);
398
399 case OBJECT_DOMAIN:
400 case OBJECT_TYPE:
401 return RenameType(stmt);
402
403 case OBJECT_AGGREGATE:
404 case OBJECT_COLLATION:
407 case OBJECT_FDW:
409 case OBJECT_FUNCTION:
410 case OBJECT_OPCLASS:
411 case OBJECT_OPFAMILY:
412 case OBJECT_LANGUAGE:
413 case OBJECT_PROCEDURE:
414 case OBJECT_ROUTINE:
418 case OBJECT_TSPARSER:
422 {
423 ObjectAddress address;
424 Relation catalog;
425
426 address = get_object_address(stmt->renameType,
427 stmt->object,
428 NULL,
429 AccessExclusiveLock, false);
430
431 catalog = table_open(address.classId, RowExclusiveLock);
433 address.objectId,
434 stmt->newname);
436
437 return address;
438 }
439
440 default:
441 elog(ERROR, "unrecognized rename stmt type: %d",
442 (int) stmt->renameType);
443 return InvalidObjectAddress; /* keep compiler happy */
444 }
445}
static void AlterObjectRename_internal(Relation rel, Oid objectId, const char *new_name)
Definition: alter.c:165
ObjectAddress RenameTableSpace(const char *oldname, const char *newname)
Definition: tablespace.c:930
ObjectAddress RenameDatabase(const char *oldname, const char *newname)
Definition: dbcommands.c:1876
@ OBJECT_POLICY
Definition: parsenodes.h:2296
@ OBJECT_COLUMN
Definition: parsenodes.h:2274
@ OBJECT_ROLE
Definition: parsenodes.h:2301
@ OBJECT_INDEX
Definition: parsenodes.h:2288
@ OBJECT_ATTRIBUTE
Definition: parsenodes.h:2272
@ OBJECT_RULE
Definition: parsenodes.h:2303
@ OBJECT_TABCONSTRAINT
Definition: parsenodes.h:2308
@ OBJECT_DOMCONSTRAINT
Definition: parsenodes.h:2281
@ OBJECT_TRIGGER
Definition: parsenodes.h:2312
ObjectAddress rename_policy(RenameStmt *stmt)
Definition: policy.c:1096
ObjectAddress RenameRewriteRule(RangeVar *relation, const char *oldName, const char *newName)
ObjectAddress RenameSchema(const char *oldname, const char *newname)
Definition: schemacmds.c:249
ObjectAddress RenameRelation(RenameStmt *stmt)
Definition: tablecmds.c:4123
ObjectAddress renameatt(RenameStmt *stmt)
Definition: tablecmds.c:3926
ObjectAddress RenameConstraint(RenameStmt *stmt)
Definition: tablecmds.c:4073
ObjectAddress renametrig(RenameStmt *stmt)
Definition: trigger.c:1463
ObjectAddress RenameType(RenameStmt *stmt)
Definition: typecmds.c:3761
ObjectAddress RenameRole(const char *oldname, const char *newname)
Definition: user.c:1334

References AccessExclusiveLock, AlterObjectRename_internal(), ObjectAddress::classId, elog, ERROR, get_object_address(), InvalidObjectAddress, OBJECT_AGGREGATE, OBJECT_ATTRIBUTE, OBJECT_COLLATION, OBJECT_COLUMN, OBJECT_CONVERSION, OBJECT_DATABASE, OBJECT_DOMAIN, OBJECT_DOMCONSTRAINT, OBJECT_EVENT_TRIGGER, OBJECT_FDW, OBJECT_FOREIGN_SERVER, OBJECT_FOREIGN_TABLE, OBJECT_FUNCTION, OBJECT_INDEX, OBJECT_LANGUAGE, OBJECT_MATVIEW, OBJECT_OPCLASS, OBJECT_OPFAMILY, OBJECT_POLICY, OBJECT_PROCEDURE, OBJECT_PUBLICATION, OBJECT_ROLE, OBJECT_ROUTINE, OBJECT_RULE, OBJECT_SCHEMA, OBJECT_SEQUENCE, OBJECT_STATISTIC_EXT, OBJECT_SUBSCRIPTION, OBJECT_TABCONSTRAINT, OBJECT_TABLE, OBJECT_TABLESPACE, OBJECT_TRIGGER, OBJECT_TSCONFIGURATION, OBJECT_TSDICTIONARY, OBJECT_TSPARSER, OBJECT_TSTEMPLATE, OBJECT_TYPE, OBJECT_VIEW, ObjectAddress::objectId, rename_policy(), renameatt(), RenameConstraint(), RenameDatabase(), RenameRelation(), RenameRewriteRule(), RenameRole(), RenameSchema(), RenameTableSpace(), renametrig(), RenameType(), RowExclusiveLock, stmt, table_close(), and table_open().

Referenced by ProcessUtilitySlow(), and standard_ProcessUtility().