PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
alter.c File Reference
#include "postgres.h"
#include "access/htup_details.h"
#include "access/relation.h"
#include "access/table.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_conversion.h"
#include "catalog/pg_database_d.h"
#include "catalog/pg_event_trigger.h"
#include "catalog/pg_foreign_data_wrapper.h"
#include "catalog/pg_foreign_server.h"
#include "catalog/pg_language.h"
#include "catalog/pg_largeobject.h"
#include "catalog/pg_largeobject_metadata.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_opfamily.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_statistic_ext.h"
#include "catalog/pg_subscription.h"
#include "catalog/pg_ts_config.h"
#include "catalog/pg_ts_dict.h"
#include "catalog/pg_ts_parser.h"
#include "catalog/pg_ts_template.h"
#include "commands/alter.h"
#include "commands/collationcmds.h"
#include "commands/dbcommands.h"
#include "commands/defrem.h"
#include "commands/event_trigger.h"
#include "commands/extension.h"
#include "commands/policy.h"
#include "commands/publicationcmds.h"
#include "commands/schemacmds.h"
#include "commands/subscriptioncmds.h"
#include "commands/tablecmds.h"
#include "commands/tablespace.h"
#include "commands/trigger.h"
#include "commands/typecmds.h"
#include "commands/user.h"
#include "miscadmin.h"
#include "replication/logicalworker.h"
#include "rewrite/rewriteDefine.h"
#include "storage/lmgr.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/syscache.h"
Include dependency graph for alter.c:

Go to the source code of this file.

Functions

static Oid AlterObjectNamespace_internal (Relation rel, Oid objid, Oid nspOid)
 
static void report_name_conflict (Oid classId, const char *name)
 
static void report_namespace_conflict (Oid classId, const char *name, Oid nspOid)
 
static void AlterObjectRename_internal (Relation rel, Oid objectId, const char *new_name)
 
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_internal()

static Oid AlterObjectNamespace_internal ( Relation  rel,
Oid  objid,
Oid  nspOid 
)
static

Definition at line 676 of file alter.c.

677{
678 Oid classId = RelationGetRelid(rel);
679 int oidCacheId = get_object_catcache_oid(classId);
680 int nameCacheId = get_object_catcache_name(classId);
681 AttrNumber Anum_name = get_object_attnum_name(classId);
682 AttrNumber Anum_namespace = get_object_attnum_namespace(classId);
683 AttrNumber Anum_owner = get_object_attnum_owner(classId);
684 Oid oldNspOid;
685 Datum name,
686 namespace;
687 bool isnull;
688 HeapTuple tup,
689 newtup;
690 Datum *values;
691 bool *nulls;
692 bool *replaces;
693
694 tup = SearchSysCacheCopy1(oidCacheId, ObjectIdGetDatum(objid));
695 if (!HeapTupleIsValid(tup)) /* should not happen */
696 elog(ERROR, "cache lookup failed for object %u of catalog \"%s\"",
697 objid, RelationGetRelationName(rel));
698
699 name = heap_getattr(tup, Anum_name, RelationGetDescr(rel), &isnull);
700 Assert(!isnull);
701 namespace = heap_getattr(tup, Anum_namespace, RelationGetDescr(rel),
702 &isnull);
703 Assert(!isnull);
704 oldNspOid = DatumGetObjectId(namespace);
705
706 /*
707 * If the object is already in the correct namespace, we don't need to do
708 * anything except fire the object access hook.
709 */
710 if (oldNspOid == nspOid)
711 {
712 InvokeObjectPostAlterHook(classId, objid, 0);
713 return oldNspOid;
714 }
715
716 /* Check basic namespace related issues */
717 CheckSetNamespace(oldNspOid, nspOid);
718
719 /* Permission checks ... superusers can always do it */
720 if (!superuser())
721 {
722 Datum owner;
723 Oid ownerId;
724 AclResult aclresult;
725
726 /* Fail if object does not have an explicit owner */
727 if (Anum_owner <= 0)
729 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
730 errmsg("must be superuser to set schema of %s",
731 getObjectDescriptionOids(classId, objid))));
732
733 /* Otherwise, must be owner of the existing object */
734 owner = heap_getattr(tup, Anum_owner, RelationGetDescr(rel), &isnull);
735 Assert(!isnull);
736 ownerId = DatumGetObjectId(owner);
737
738 if (!has_privs_of_role(GetUserId(), ownerId))
741
742 /* User must have CREATE privilege on new namespace */
743 aclresult = object_aclcheck(NamespaceRelationId, nspOid, GetUserId(), ACL_CREATE);
744 if (aclresult != ACLCHECK_OK)
745 aclcheck_error(aclresult, OBJECT_SCHEMA,
746 get_namespace_name(nspOid));
747 }
748
749 /*
750 * Check for duplicate name (more friendly than unique-index failure).
751 * Since this is just a friendliness check, we can just skip it in cases
752 * where there isn't suitable support.
753 */
754 if (classId == ProcedureRelationId)
755 {
756 Form_pg_proc proc = (Form_pg_proc) GETSTRUCT(tup);
757
758 IsThereFunctionInNamespace(NameStr(proc->proname), proc->pronargs,
759 &proc->proargtypes, nspOid);
760 }
761 else if (classId == CollationRelationId)
762 {
764
765 IsThereCollationInNamespace(NameStr(coll->collname), nspOid);
766 }
767 else if (classId == OperatorClassRelationId)
768 {
770
772 opc->opcmethod, nspOid);
773 }
774 else if (classId == OperatorFamilyRelationId)
775 {
777
779 opf->opfmethod, nspOid);
780 }
781 else if (nameCacheId >= 0 &&
782 SearchSysCacheExists2(nameCacheId, name,
783 ObjectIdGetDatum(nspOid)))
786 nspOid);
787
788 /* Build modified tuple */
790 nulls = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool));
791 replaces = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool));
792 values[Anum_namespace - 1] = ObjectIdGetDatum(nspOid);
793 replaces[Anum_namespace - 1] = true;
794 newtup = heap_modify_tuple(tup, RelationGetDescr(rel),
795 values, nulls, replaces);
796
797 /* Perform actual update */
798 CatalogTupleUpdate(rel, &tup->t_self, newtup);
799
800 /* Release memory */
801 pfree(values);
802 pfree(nulls);
803 pfree(replaces);
804
805 /* update dependency to point to the new schema */
806 if (changeDependencyFor(classId, objid,
807 NamespaceRelationId, oldNspOid, nspOid) != 1)
808 elog(ERROR, "could not change schema dependency for object %u",
809 objid);
810
811 InvokeObjectPostAlterHook(classId, objid, 0);
812
813 return oldNspOid;
814}
bool has_privs_of_role(Oid member, Oid role)
Definition: acl.c:5268
AclResult
Definition: acl.h:182
@ ACLCHECK_OK
Definition: acl.h:183
@ ACLCHECK_NOT_OWNER
Definition: acl.h:185
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
static void report_namespace_conflict(Oid classId, const char *name, Oid nspOid)
Definition: alter.c:111
int16 AttrNumber
Definition: attnum.h:21
static Datum values[MAXATTR]
Definition: bootstrap.c:151
#define NameStr(name)
Definition: c.h:700
#define Assert(condition)
Definition: c.h:812
void IsThereCollationInNamespace(const char *collname, Oid nspOid)
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
#define ereport(elevel,...)
Definition: elog.h:149
void IsThereFunctionInNamespace(const char *proname, int pronargs, oidvector *proargtypes, Oid nspOid)
HeapTuple heap_modify_tuple(HeapTuple tuple, TupleDesc tupleDesc, const Datum *replValues, const bool *replIsnull, const bool *doReplace)
Definition: heaptuple.c:1210
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
static Datum heap_getattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
Definition: htup_details.h:792
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
void CatalogTupleUpdate(Relation heapRel, ItemPointer otid, HeapTuple tup)
Definition: indexing.c:313
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
void CheckSetNamespace(Oid oldNspOid, Oid nspOid)
Definition: namespace.c:3459
#define InvokeObjectPostAlterHook(classId, objectId, subId)
Definition: objectaccess.h:197
int get_object_catcache_name(Oid class_id)
AttrNumber get_object_attnum_owner(Oid class_id)
AttrNumber get_object_attnum_namespace(Oid class_id)
char * getObjectDescriptionOids(Oid classid, Oid objid)
AttrNumber get_object_attnum_name(Oid class_id)
int get_object_catcache_oid(Oid class_id)
ObjectType get_object_type(Oid class_id, Oid object_id)
void IsThereOpFamilyInNamespace(const char *opfname, Oid opfmethod, Oid opfnamespace)
Definition: opclasscmds.c:1828
void IsThereOpClassInNamespace(const char *opcname, Oid opcmethod, Oid opcnamespace)
Definition: opclasscmds.c:1805
@ OBJECT_SCHEMA
Definition: parsenodes.h:2304
#define ACL_CREATE
Definition: parsenodes.h:85
FormData_pg_collation * Form_pg_collation
Definition: pg_collation.h:58
long changeDependencyFor(Oid classId, Oid objectId, Oid refClassId, Oid oldRefObjectId, Oid newRefObjectId)
Definition: pg_depend.c:457
FormData_pg_opclass * Form_pg_opclass
Definition: pg_opclass.h:83
FormData_pg_opfamily * Form_pg_opfamily
Definition: pg_opfamily.h:51
FormData_pg_proc * Form_pg_proc
Definition: pg_proc.h:136
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
unsigned int Oid
Definition: postgres_ext.h:31
#define RelationGetRelid(relation)
Definition: rel.h:505
#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
#define SearchSysCacheCopy1(cacheId, key1)
Definition: syscache.h:91
#define SearchSysCacheExists2(cacheId, key1, key2)
Definition: syscache.h:102
const char * name

References ACL_CREATE, aclcheck_error(), ACLCHECK_NOT_OWNER, ACLCHECK_OK, Assert, CatalogTupleUpdate(), changeDependencyFor(), CheckSetNamespace(), DatumGetName(), DatumGetObjectId(), elog, ereport, errcode(), errmsg(), ERROR, get_namespace_name(), get_object_attnum_name(), get_object_attnum_namespace(), get_object_attnum_owner(), get_object_catcache_name(), get_object_catcache_oid(), get_object_type(), getObjectDescriptionOids(), GETSTRUCT, GetUserId(), has_privs_of_role(), heap_getattr(), heap_modify_tuple(), HeapTupleIsValid, InvokeObjectPostAlterHook, IsThereCollationInNamespace(), IsThereFunctionInNamespace(), IsThereOpClassInNamespace(), IsThereOpFamilyInNamespace(), name, NameStr, object_aclcheck(), OBJECT_SCHEMA, ObjectIdGetDatum(), palloc0(), pfree(), RelationGetDescr, RelationGetNumberOfAttributes, RelationGetRelationName, RelationGetRelid, report_namespace_conflict(), SearchSysCacheCopy1, SearchSysCacheExists2, superuser(), HeapTupleData::t_self, and values.

Referenced by AlterObjectNamespace_oid(), and ExecAlterObjectSchemaStmt().

◆ 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 NoLock
Definition: lockdefs.h:34
#define AccessExclusiveLock
Definition: lockdefs.h:43
#define RowExclusiveLock
Definition: lockdefs.h:38
#define InvalidOid
Definition: postgres_ext.h:36
#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:17785
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}
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
#define DatumGetAclP(X)
Definition: acl.h:120
#define OidIsValid(objectId)
Definition: c.h:729
void UnlockTuple(Relation relation, ItemPointer tid, LOCKMODE lockmode)
Definition: lmgr.c:594
#define InplaceUpdateTupleLock
Definition: lockdefs.h:48
AttrNumber get_object_attnum_oid(Oid class_id)
AttrNumber get_object_attnum_acl(Oid class_id)
HeapTuple get_catalog_object_by_oid_extended(Relation catalog, AttrNumber oidcol, Oid objectId, bool locktup)
#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

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().

◆ AlterObjectRename_internal()

static void AlterObjectRename_internal ( Relation  rel,
Oid  objectId,
const char *  new_name 
)
static

Definition at line 165 of file alter.c.

166{
167 Oid classId = RelationGetRelid(rel);
168 int oidCacheId = get_object_catcache_oid(classId);
169 int nameCacheId = get_object_catcache_name(classId);
170 AttrNumber Anum_name = get_object_attnum_name(classId);
171 AttrNumber Anum_namespace = get_object_attnum_namespace(classId);
172 AttrNumber Anum_owner = get_object_attnum_owner(classId);
173 HeapTuple oldtup;
174 HeapTuple newtup;
175 Datum datum;
176 bool isnull;
177 Oid namespaceId;
178 Oid ownerId;
179 char *old_name;
180 AclResult aclresult;
181 Datum *values;
182 bool *nulls;
183 bool *replaces;
184 NameData nameattrdata;
185
186 oldtup = SearchSysCache1(oidCacheId, ObjectIdGetDatum(objectId));
187 if (!HeapTupleIsValid(oldtup))
188 elog(ERROR, "cache lookup failed for object %u of catalog \"%s\"",
189 objectId, RelationGetRelationName(rel));
190
191 datum = heap_getattr(oldtup, Anum_name,
192 RelationGetDescr(rel), &isnull);
193 Assert(!isnull);
194 old_name = NameStr(*(DatumGetName(datum)));
195
196 /* Get OID of namespace */
197 if (Anum_namespace > 0)
198 {
199 datum = heap_getattr(oldtup, Anum_namespace,
200 RelationGetDescr(rel), &isnull);
201 Assert(!isnull);
202 namespaceId = DatumGetObjectId(datum);
203 }
204 else
205 namespaceId = InvalidOid;
206
207 /* Permission checks ... superusers can always do it */
208 if (!superuser())
209 {
210 /* Fail if object does not have an explicit owner */
211 if (Anum_owner <= 0)
213 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
214 errmsg("must be superuser to rename %s",
215 getObjectDescriptionOids(classId, objectId))));
216
217 /* Otherwise, must be owner of the existing object */
218 datum = heap_getattr(oldtup, Anum_owner,
219 RelationGetDescr(rel), &isnull);
220 Assert(!isnull);
221 ownerId = DatumGetObjectId(datum);
222
225 old_name);
226
227 /* User must have CREATE privilege on the namespace */
228 if (OidIsValid(namespaceId))
229 {
230 aclresult = object_aclcheck(NamespaceRelationId, namespaceId, GetUserId(),
231 ACL_CREATE);
232 if (aclresult != ACLCHECK_OK)
233 aclcheck_error(aclresult, OBJECT_SCHEMA,
234 get_namespace_name(namespaceId));
235 }
236
237 if (classId == SubscriptionRelationId)
238 {
240
241 /* must have CREATE privilege on database */
242 aclresult = object_aclcheck(DatabaseRelationId, MyDatabaseId,
244 if (aclresult != ACLCHECK_OK)
247
248 /*
249 * Don't allow non-superuser modification of a subscription with
250 * password_required=false.
251 */
252 form = (Form_pg_subscription) GETSTRUCT(oldtup);
253 if (!form->subpasswordrequired && !superuser())
255 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
256 errmsg("password_required=false is superuser-only"),
257 errhint("Subscriptions with the password_required option set to false may only be created or modified by the superuser.")));
258 }
259 }
260
261 /*
262 * Check for duplicate name (more friendly than unique-index failure).
263 * Since this is just a friendliness check, we can just skip it in cases
264 * where there isn't suitable support.
265 */
266 if (classId == ProcedureRelationId)
267 {
268 Form_pg_proc proc = (Form_pg_proc) GETSTRUCT(oldtup);
269
270 IsThereFunctionInNamespace(new_name, proc->pronargs,
271 &proc->proargtypes, proc->pronamespace);
272 }
273 else if (classId == CollationRelationId)
274 {
276
277 IsThereCollationInNamespace(new_name, coll->collnamespace);
278 }
279 else if (classId == OperatorClassRelationId)
280 {
282
283 IsThereOpClassInNamespace(new_name, opc->opcmethod,
284 opc->opcnamespace);
285 }
286 else if (classId == OperatorFamilyRelationId)
287 {
289
290 IsThereOpFamilyInNamespace(new_name, opf->opfmethod,
291 opf->opfnamespace);
292 }
293 else if (classId == SubscriptionRelationId)
294 {
295 if (SearchSysCacheExists2(SUBSCRIPTIONNAME,
297 CStringGetDatum(new_name)))
298 report_name_conflict(classId, new_name);
299
300 /* Also enforce regression testing naming rules, if enabled */
301#ifdef ENFORCE_REGRESSION_TEST_NAME_RESTRICTIONS
302 if (strncmp(new_name, "regress_", 8) != 0)
303 elog(WARNING, "subscriptions created by regression test cases should have names starting with \"regress_\"");
304#endif
305
306 /* Wake up related replication workers to handle this change quickly */
308 }
309 else if (nameCacheId >= 0)
310 {
311 if (OidIsValid(namespaceId))
312 {
313 if (SearchSysCacheExists2(nameCacheId,
314 CStringGetDatum(new_name),
315 ObjectIdGetDatum(namespaceId)))
316 report_namespace_conflict(classId, new_name, namespaceId);
317 }
318 else
319 {
320 if (SearchSysCacheExists1(nameCacheId,
321 CStringGetDatum(new_name)))
322 report_name_conflict(classId, new_name);
323 }
324 }
325
326 /* Build modified tuple */
328 nulls = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool));
329 replaces = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool));
330 namestrcpy(&nameattrdata, new_name);
331 values[Anum_name - 1] = NameGetDatum(&nameattrdata);
332 replaces[Anum_name - 1] = true;
333 newtup = heap_modify_tuple(oldtup, RelationGetDescr(rel),
334 values, nulls, replaces);
335
336 /* Perform actual update */
337 CatalogTupleUpdate(rel, &oldtup->t_self, newtup);
338
339 InvokeObjectPostAlterHook(classId, objectId, 0);
340
341 /* Release memory */
342 pfree(values);
343 pfree(nulls);
344 pfree(replaces);
345 heap_freetuple(newtup);
346
347 ReleaseSysCache(oldtup);
348}
static void report_name_conflict(Oid classId, const char *name)
Definition: alter.c:76
void LogicalRepWorkersWakeupAtCommit(Oid subid)
Definition: worker.c:5102
char * get_database_name(Oid dbid)
Definition: dbcommands.c:3187
int errhint(const char *fmt,...)
Definition: elog.c:1317
#define WARNING
Definition: elog.h:36
Oid MyDatabaseId
Definition: globals.c:93
void heap_freetuple(HeapTuple htup)
Definition: heaptuple.c:1435
void namestrcpy(Name name, const char *str)
Definition: name.c:233
@ OBJECT_DATABASE
Definition: parsenodes.h:2277
FormData_pg_subscription * Form_pg_subscription
static Datum NameGetDatum(const NameData *X)
Definition: postgres.h:373
static Datum CStringGetDatum(const char *X)
Definition: postgres.h:350
Definition: c.h:695
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:269
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:221
#define SearchSysCacheExists1(cacheId, key1)
Definition: syscache.h:100

References ACL_CREATE, aclcheck_error(), ACLCHECK_NOT_OWNER, ACLCHECK_OK, Assert, CatalogTupleUpdate(), CStringGetDatum(), DatumGetName(), DatumGetObjectId(), elog, ereport, errcode(), errhint(), errmsg(), ERROR, get_database_name(), get_namespace_name(), get_object_attnum_name(), get_object_attnum_namespace(), get_object_attnum_owner(), get_object_catcache_name(), get_object_catcache_oid(), get_object_type(), getObjectDescriptionOids(), GETSTRUCT, GetUserId(), has_privs_of_role(), heap_freetuple(), heap_getattr(), heap_modify_tuple(), HeapTupleIsValid, InvalidOid, InvokeObjectPostAlterHook, IsThereCollationInNamespace(), IsThereFunctionInNamespace(), IsThereOpClassInNamespace(), IsThereOpFamilyInNamespace(), LogicalRepWorkersWakeupAtCommit(), MyDatabaseId, NameGetDatum(), NameStr, namestrcpy(), object_aclcheck(), OBJECT_DATABASE, OBJECT_SCHEMA, ObjectIdGetDatum(), OidIsValid, palloc0(), pfree(), RelationGetDescr, RelationGetNumberOfAttributes, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), report_name_conflict(), report_namespace_conflict(), SearchSysCache1(), SearchSysCacheExists1, SearchSysCacheExists2, superuser(), HeapTupleData::t_self, values, and WARNING.

Referenced by ExecRenameStmt().

◆ 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:17714
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_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:4124
ObjectAddress renameatt(RenameStmt *stmt)
Definition: tablecmds.c:3927
ObjectAddress RenameConstraint(RenameStmt *stmt)
Definition: tablecmds.c:4074
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().

◆ report_name_conflict()

static void report_name_conflict ( Oid  classId,
const char *  name 
)
static

Definition at line 76 of file alter.c.

77{
78 char *msgfmt;
79
80 switch (classId)
81 {
82 case EventTriggerRelationId:
83 msgfmt = gettext_noop("event trigger \"%s\" already exists");
84 break;
85 case ForeignDataWrapperRelationId:
86 msgfmt = gettext_noop("foreign-data wrapper \"%s\" already exists");
87 break;
88 case ForeignServerRelationId:
89 msgfmt = gettext_noop("server \"%s\" already exists");
90 break;
91 case LanguageRelationId:
92 msgfmt = gettext_noop("language \"%s\" already exists");
93 break;
94 case PublicationRelationId:
95 msgfmt = gettext_noop("publication \"%s\" already exists");
96 break;
97 case SubscriptionRelationId:
98 msgfmt = gettext_noop("subscription \"%s\" already exists");
99 break;
100 default:
101 elog(ERROR, "unsupported object class: %u", classId);
102 break;
103 }
104
107 errmsg(msgfmt, name)));
108}
#define gettext_noop(x)
Definition: c.h:1150
#define ERRCODE_DUPLICATE_OBJECT
Definition: streamutil.c:30

References elog, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, gettext_noop, and name.

Referenced by AlterObjectRename_internal().

◆ report_namespace_conflict()

static void report_namespace_conflict ( Oid  classId,
const char *  name,
Oid  nspOid 
)
static

Definition at line 111 of file alter.c.

112{
113 char *msgfmt;
114
115 Assert(OidIsValid(nspOid));
116
117 switch (classId)
118 {
119 case ConversionRelationId:
120 Assert(OidIsValid(nspOid));
121 msgfmt = gettext_noop("conversion \"%s\" already exists in schema \"%s\"");
122 break;
123 case StatisticExtRelationId:
124 Assert(OidIsValid(nspOid));
125 msgfmt = gettext_noop("statistics object \"%s\" already exists in schema \"%s\"");
126 break;
127 case TSParserRelationId:
128 Assert(OidIsValid(nspOid));
129 msgfmt = gettext_noop("text search parser \"%s\" already exists in schema \"%s\"");
130 break;
131 case TSDictionaryRelationId:
132 Assert(OidIsValid(nspOid));
133 msgfmt = gettext_noop("text search dictionary \"%s\" already exists in schema \"%s\"");
134 break;
135 case TSTemplateRelationId:
136 Assert(OidIsValid(nspOid));
137 msgfmt = gettext_noop("text search template \"%s\" already exists in schema \"%s\"");
138 break;
139 case TSConfigRelationId:
140 Assert(OidIsValid(nspOid));
141 msgfmt = gettext_noop("text search configuration \"%s\" already exists in schema \"%s\"");
142 break;
143 default:
144 elog(ERROR, "unsupported object class: %u", classId);
145 break;
146 }
147
150 errmsg(msgfmt, name, get_namespace_name(nspOid))));
151}

References Assert, elog, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, get_namespace_name(), gettext_noop, name, and OidIsValid.

Referenced by AlterObjectNamespace_internal(), and AlterObjectRename_internal().