Quelle  alter.c

/*-------------------------------------------------------------------------
 *
 * alter.c
 *   Drivers for generic alter commands
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *   src/backend/commands/alter.c
 *
 *-------------------------------------------------------------------------
 */
#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"

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

/*
 * Raise an error to the effect that an object of the given name is already
 * present in the given namespace.
 */
static void
report_name_conflict(Oid classId, const char *name)
{
 char    *msgfmt;

 switch (classId)
 {
  case EventTriggerRelationId:
   msgfmt = gettext_noop("event trigger \"%s\" already exists");
   break;
  case ForeignDataWrapperRelationId:
   msgfmt = gettext_noop("foreign-data wrapper \"%s\" already exists");
   break;
  case ForeignServerRelationId:
   msgfmt = gettext_noop("server \"%s\" already exists");
   break;
  case LanguageRelationId:
   msgfmt = gettext_noop("language \"%s\" already exists");
   break;
  case PublicationRelationId:
   msgfmt = gettext_noop("publication \"%s\" already exists");
   break;
  case SubscriptionRelationId:
   msgfmt = gettext_noop("subscription \"%s\" already exists");
   break;
  default:
   elog(ERROR, "unsupported object class: %u", classId);
   break;
 }

 ereport(ERROR,
   (errcode(ERRCODE_DUPLICATE_OBJECT),
    errmsg(msgfmt, name)));
}

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

 Assert(OidIsValid(nspOid));

 switch (classId)
 {
  case ConversionRelationId:
   Assert(OidIsValid(nspOid));
   msgfmt = gettext_noop("conversion \"%s\" already exists in schema \"%s\"");
   break;
  case StatisticExtRelationId:
   Assert(OidIsValid(nspOid));
   msgfmt = gettext_noop("statistics object \"%s\" already exists in schema \"%s\"");
   break;
  case TSParserRelationId:
   Assert(OidIsValid(nspOid));
   msgfmt = gettext_noop("text search parser \"%s\" already exists in schema \"%s\"");
   break;
  case TSDictionaryRelationId:
   Assert(OidIsValid(nspOid));
   msgfmt = gettext_noop("text search dictionary \"%s\" already exists in schema \"%s\"");
   break;
  case TSTemplateRelationId:
   Assert(OidIsValid(nspOid));
   msgfmt = gettext_noop("text search template \"%s\" already exists in schema \"%s\"");
   break;
  case TSConfigRelationId:
   Assert(OidIsValid(nspOid));
   msgfmt = gettext_noop("text search configuration \"%s\" already exists in schema \"%s\"");
   break;
  default:
   elog(ERROR, "unsupported object class: %u", classId);
   break;
 }

 ereport(ERROR,
   (errcode(ERRCODE_DUPLICATE_OBJECT),
    errmsg(msgfmt, name, get_namespace_name(nspOid))));
}

/*
 * AlterObjectRename_internal
 *
 * Generic function to rename the given object, for simple cases (won't
 * work for tables, nor other cases where we need to do more than change
 * the name column of a single catalog entry).
 *
 * rel: catalog relation containing object (RowExclusiveLock'd by caller)
 * objectId: OID of object to be renamed
 * new_name: CString representation of new name
 */
static void
AlterObjectRename_internal(Relation rel, Oid objectId, const char *new_name)
{
 Oid   classId = RelationGetRelid(rel);
 int   oidCacheId = get_object_catcache_oid(classId);
 int   nameCacheId = get_object_catcache_name(classId);
 AttrNumber Anum_name = get_object_attnum_name(classId);
 AttrNumber Anum_namespace = get_object_attnum_namespace(classId);
 AttrNumber Anum_owner = get_object_attnum_owner(classId);
 HeapTuple oldtup;
 HeapTuple newtup;
 Datum  datum;
 bool  isnull;
 Oid   namespaceId;
 Oid   ownerId;
 char    *old_name;
 AclResult aclresult;
 Datum    *values;
 bool    *nulls;
 bool    *replaces;
 NameData nameattrdata;

 oldtup = SearchSysCache1(oidCacheId, ObjectIdGetDatum(objectId));
 if (!HeapTupleIsValid(oldtup))
  elog(ERROR, "cache lookup failed for object %u of catalog \"%s\"",
    objectId, RelationGetRelationName(rel));

 datum = heap_getattr(oldtup, Anum_name,
       RelationGetDescr(rel), &isnull);
 Assert(!isnull);
 old_name = NameStr(*(DatumGetName(datum)));

 /* Get OID of namespace */
 if (Anum_namespace > 0)
 {
  datum = heap_getattr(oldtup, Anum_namespace,
        RelationGetDescr(rel), &isnull);
  Assert(!isnull);
  namespaceId = DatumGetObjectId(datum);
 }
 else
  namespaceId = InvalidOid;

 /* Permission checks ... superusers can always do it */
 if (!superuser())
 {
  /* Fail if object does not have an explicit owner */
  if (Anum_owner <= 0)
   ereport(ERROR,
     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
      errmsg("must be superuser to rename %s",
       getObjectDescriptionOids(classId, objectId))));

  /* Otherwise, must be owner of the existing object */
  datum = heap_getattr(oldtup, Anum_owner,
        RelationGetDescr(rel), &isnull);
  Assert(!isnull);
  ownerId = DatumGetObjectId(datum);

  if (!has_privs_of_role(GetUserId(), DatumGetObjectId(ownerId)))
   aclcheck_error(ACLCHECK_NOT_OWNER, get_object_type(classId, objectId),
         old_name);

  /* User must have CREATE privilege on the namespace */
  if (OidIsValid(namespaceId))
  {
   aclresult = object_aclcheck(NamespaceRelationId, namespaceId, GetUserId(),
          ACL_CREATE);
   if (aclresult != ACLCHECK_OK)
    aclcheck_error(aclresult, OBJECT_SCHEMA,
          get_namespace_name(namespaceId));
  }

  if (classId == SubscriptionRelationId)
  {
   Form_pg_subscription form;

   /* must have CREATE privilege on database */
   aclresult = object_aclcheck(DatabaseRelationId, MyDatabaseId,
          GetUserId(), ACL_CREATE);
   if (aclresult != ACLCHECK_OK)
    aclcheck_error(aclresult, OBJECT_DATABASE,
          get_database_name(MyDatabaseId));

   /*
    * Don't allow non-superuser modification of a subscription with
    * password_required=false.
 */
   form = (Form_pg_subscription) GETSTRUCT(oldtup);
   if (!form->subpasswordrequired && !superuser())
    ereport(ERROR,
      (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
       errmsg("password_required=false is superuser-only"),
       errhint("Subscriptions with the password_required option set to false may only be created or modified by the superuser.")));
  }
 }

 /*
  * Check for duplicate name (more friendly than unique-index failure).
  * Since this is just a friendliness check, we can just skip it in cases
  * where there isn't suitable support.
 */
 if (classId == ProcedureRelationId)
 {
  Form_pg_proc proc = (Form_pg_proc) GETSTRUCT(oldtup);

  IsThereFunctionInNamespace(new_name, proc->pronargs,
           &proc->proargtypes, proc->pronamespace);
 }
 else if (classId == CollationRelationId)
 {
  Form_pg_collation coll = (Form_pg_collation) GETSTRUCT(oldtup);

  IsThereCollationInNamespace(new_name, coll->collnamespace);
 }
 else if (classId == OperatorClassRelationId)
 {
  Form_pg_opclass opc = (Form_pg_opclass) GETSTRUCT(oldtup);

  IsThereOpClassInNamespace(new_name, opc->opcmethod,
          opc->opcnamespace);
 }
 else if (classId == OperatorFamilyRelationId)
 {
  Form_pg_opfamily opf = (Form_pg_opfamily) GETSTRUCT(oldtup);

  IsThereOpFamilyInNamespace(new_name, opf->opfmethod,
           opf->opfnamespace);
 }
 else if (classId == SubscriptionRelationId)
 {
  if (SearchSysCacheExists2(SUBSCRIPTIONNAME,
          ObjectIdGetDatum(MyDatabaseId),
          CStringGetDatum(new_name)))
   report_name_conflict(classId, new_name);

  /* Also enforce regression testing naming rules, if enabled */
#ifdef ENFORCE_REGRESSION_TEST_NAME_RESTRICTIONS
  if (strncmp(new_name, "regress_", 8) != 0)
   elog(WARNING, "subscriptions created by regression test cases should have names starting with \"regress_\"");
#endif

  /* Wake up related replication workers to handle this change quickly */
  LogicalRepWorkersWakeupAtCommit(objectId);
 }
 else if (nameCacheId >= 0)
 {
  if (OidIsValid(namespaceId))
  {
   if (SearchSysCacheExists2(nameCacheId,
           CStringGetDatum(new_name),
           ObjectIdGetDatum(namespaceId)))
    report_namespace_conflict(classId, new_name, namespaceId);
  }
  else
  {
   if (SearchSysCacheExists1(nameCacheId,
           CStringGetDatum(new_name)))
    report_name_conflict(classId, new_name);
  }
 }

 /* Build modified tuple */
 values = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(Datum));
 nulls = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool));
 replaces = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool));
 namestrcpy(&nameattrdata, new_name);
 values[Anum_name - 1] = NameGetDatum(&nameattrdata);
 replaces[Anum_name - 1] = true;
 newtup = heap_modify_tuple(oldtup, RelationGetDescr(rel),
          values, nulls, replaces);

 /* Perform actual update */
 CatalogTupleUpdate(rel, &oldtup->t_self, newtup);

 InvokeObjectPostAlterHook(classId, objectId, 0);

 /* Do post catalog-update tasks */
 if (classId == PublicationRelationId)
 {
  Form_pg_publication pub = (Form_pg_publication) GETSTRUCT(oldtup);

  /*
   * Invalidate relsynccache entries.
   *
   * Unlike ALTER PUBLICATION ADD/SET/DROP commands, renaming a
   * publication does not impact the publication status of tables. So,
   * we don't need to invalidate relcache to rebuild the rd_pubdesc.
   * Instead, we invalidate only the relsyncache.
 */
  InvalidatePubRelSyncCache(pub->oid, pub->puballtables);
 }

 /* Release memory */
 pfree(values);
 pfree(nulls);
 pfree(replaces);
 heap_freetuple(newtup);

 ReleaseSysCache(oldtup);
}

/*
 * Executes an ALTER OBJECT / RENAME TO statement.  Based on the object
 * type, the function appropriate to that type is executed.
 *
 * Return value is the address of the renamed object.
 */
ObjectAddress
ExecRenameStmt(RenameStmt *stmt)
{
 switch (stmt->renameType)
 {
  case OBJECT_TABCONSTRAINT:
  case OBJECT_DOMCONSTRAINT:
   return RenameConstraint(stmt);

  case OBJECT_DATABASE:
   return RenameDatabase(stmt->subname, stmt->newname);

  case OBJECT_ROLE:
   return RenameRole(stmt->subname, stmt->newname);

  case OBJECT_SCHEMA:
   return RenameSchema(stmt->subname, stmt->newname);

  case OBJECT_TABLESPACE:
   return RenameTableSpace(stmt->subname, stmt->newname);

  case OBJECT_TABLE:
  case OBJECT_SEQUENCE:
  case OBJECT_VIEW:
  case OBJECT_MATVIEW:
  case OBJECT_INDEX:
  case OBJECT_FOREIGN_TABLE:
   return RenameRelation(stmt);

  case OBJECT_COLUMN:
  case OBJECT_ATTRIBUTE:
   return renameatt(stmt);

  case OBJECT_RULE:
   return RenameRewriteRule(stmt->relation, stmt->subname,
          stmt->newname);

  case OBJECT_TRIGGER:
   return renametrig(stmt);

  case OBJECT_POLICY:
   return rename_policy(stmt);

  case OBJECT_DOMAIN:
  case OBJECT_TYPE:
   return RenameType(stmt);

  case OBJECT_AGGREGATE:
  case OBJECT_COLLATION:
  case OBJECT_CONVERSION:
  case OBJECT_EVENT_TRIGGER:
  case OBJECT_FDW:
  case OBJECT_FOREIGN_SERVER:
  case OBJECT_FUNCTION:
  case OBJECT_OPCLASS:
  case OBJECT_OPFAMILY:
  case OBJECT_LANGUAGE:
  case OBJECT_PROCEDURE:
  case OBJECT_ROUTINE:
  case OBJECT_STATISTIC_EXT:
  case OBJECT_TSCONFIGURATION:
  case OBJECT_TSDICTIONARY:
  case OBJECT_TSPARSER:
  case OBJECT_TSTEMPLATE:
  case OBJECT_PUBLICATION:
  case OBJECT_SUBSCRIPTION:
   {
    ObjectAddress address;
    Relation catalog;

    address = get_object_address(stmt->renameType,
            stmt->object,
            NULL,
            AccessExclusiveLock, false);

    catalog = table_open(address.classId, RowExclusiveLock);
    AlterObjectRename_internal(catalog,
             address.objectId,
             stmt->newname);
    table_close(catalog, RowExclusiveLock);

    return address;
   }

  default:
   elog(ERROR, "unrecognized rename stmt type: %d",
     (int) stmt->renameType);
   return InvalidObjectAddress; /* keep compiler happy */
 }
}

/*
 * Executes an ALTER OBJECT / [NO] DEPENDS ON EXTENSION statement.
 *
 * Return value is the address of the altered object.  refAddress is an output
 * argument which, if not null, receives the address of the object that the
 * altered object now depends on.
 */
ObjectAddress
ExecAlterObjectDependsStmt(AlterObjectDependsStmt *stmt, ObjectAddress *refAddress)
{
 ObjectAddress address;
 ObjectAddress refAddr;
 Relation rel;

 address =
  get_object_address_rv(stmt->objectType, stmt->relation, (List *) stmt->object,
         &rel, AccessExclusiveLock, false);

 /*
  * Verify that the user is entitled to run the command.
  *
  * We don't check any privileges on the extension, because that's not
  * needed.  The object owner is stipulating, by running this command, that
  * the extension owner can drop the object whenever they feel like it,
  * which is not considered a problem.
 */
 check_object_ownership(GetUserId(),
         stmt->objectType, address, stmt->object, rel);

 /*
  * If a relation was involved, it would have been opened and locked. We
  * don't need the relation here, but we'll retain the lock until commit.
 */
 if (rel)
  table_close(rel, NoLock);

 refAddr = get_object_address(OBJECT_EXTENSION, (Node *) stmt->extname,
         NULL, AccessExclusiveLock, false);
 if (refAddress)
  *refAddress = refAddr;

 if (stmt->remove)
 {
  deleteDependencyRecordsForSpecific(address.classId, address.objectId,
             DEPENDENCY_AUTO_EXTENSION,
             refAddr.classId, refAddr.objectId);
 }
 else
 {
  List    *currexts;

  /* Avoid duplicates */
  currexts = getAutoExtensionsOfObject(address.classId,
            address.objectId);
  if (!list_member_oid(currexts, refAddr.objectId))
   recordDependencyOn(&address, &refAddr, DEPENDENCY_AUTO_EXTENSION);
 }

 return address;
}

/*
 * Executes an ALTER OBJECT / SET SCHEMA statement.  Based on the object
 * type, the function appropriate to that type is executed.
 *
 * Return value is that of the altered object.
 *
 * oldSchemaAddr is an output argument which, if not NULL, is set to the object
 * address of the original schema.
 */
ObjectAddress
ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *stmt,
        ObjectAddress *oldSchemaAddr)
{
 ObjectAddress address;
 Oid   oldNspOid;

 switch (stmt->objectType)
 {
  case OBJECT_EXTENSION:
   address = AlterExtensionNamespace(strVal(stmt->object), stmt->newschema,
             oldSchemaAddr ? &oldNspOid : NULL);
   break;

  case OBJECT_FOREIGN_TABLE:
  case OBJECT_SEQUENCE:
  case OBJECT_TABLE:
  case OBJECT_VIEW:
  case OBJECT_MATVIEW:
   address = AlterTableNamespace(stmt,
            oldSchemaAddr ? &oldNspOid : NULL);
   break;

  case OBJECT_DOMAIN:
  case OBJECT_TYPE:
   address = AlterTypeNamespace(castNode(List, stmt->object), stmt->newschema,
           stmt->objectType,
           oldSchemaAddr ? &oldNspOid : NULL);
   break;

   /* generic code path */
  case OBJECT_AGGREGATE:
  case OBJECT_COLLATION:
  case OBJECT_CONVERSION:
  case OBJECT_FUNCTION:
  case OBJECT_OPERATOR:
  case OBJECT_OPCLASS:
  case OBJECT_OPFAMILY:
  case OBJECT_PROCEDURE:
  case OBJECT_ROUTINE:
  case OBJECT_STATISTIC_EXT:
  case OBJECT_TSCONFIGURATION:
  case OBJECT_TSDICTIONARY:
  case OBJECT_TSPARSER:
  case OBJECT_TSTEMPLATE:
   {
    Relation catalog;
    Oid   classId;
    Oid   nspOid;

    address = get_object_address(stmt->objectType,
            stmt->object,
            NULL,
            AccessExclusiveLock,
            false);
    classId = address.classId;
    catalog = table_open(classId, RowExclusiveLock);
    nspOid = LookupCreationNamespace(stmt->newschema);

    oldNspOid = AlterObjectNamespace_internal(catalog, address.objectId,
                nspOid);
    table_close(catalog, RowExclusiveLock);
   }
   break;

  default:
   elog(ERROR, "unrecognized AlterObjectSchemaStmt type: %d",
     (int) stmt->objectType);
   return InvalidObjectAddress; /* keep compiler happy */
 }

 if (oldSchemaAddr)
  ObjectAddressSet(*oldSchemaAddr, NamespaceRelationId, oldNspOid);

 return address;
}

/*
 * Change an object's namespace given its classOid and object Oid.
 *
 * Objects that don't have a namespace should be ignored, as should
 * dependent types such as array types.
 *
 * This function is currently used only by ALTER EXTENSION SET SCHEMA,
 * so it only needs to cover object kinds that can be members of an
 * extension, and it can silently ignore dependent types --- we assume
 * those will be moved when their parent object is moved.
 *
 * Returns the OID of the object's previous namespace, or InvalidOid if
 * object doesn't have a schema or was ignored due to being a dependent type.
 */
Oid
AlterObjectNamespace_oid(Oid classId, Oid objid, Oid nspOid,
       ObjectAddresses *objsMoved)
{
 Oid   oldNspOid = InvalidOid;

 switch (classId)
 {
  case RelationRelationId:
   {
    Relation rel;

    rel = relation_open(objid, AccessExclusiveLock);
    oldNspOid = RelationGetNamespace(rel);

    AlterTableNamespaceInternal(rel, oldNspOid, nspOid, objsMoved);

    relation_close(rel, NoLock);
    break;
   }

  case TypeRelationId:
   oldNspOid = AlterTypeNamespace_oid(objid, nspOid, true, objsMoved);
   break;

  case ProcedureRelationId:
  case CollationRelationId:
  case ConversionRelationId:
  case OperatorRelationId:
  case OperatorClassRelationId:
  case OperatorFamilyRelationId:
  case StatisticExtRelationId:
  case TSParserRelationId:
  case TSDictionaryRelationId:
  case TSTemplateRelationId:
  case TSConfigRelationId:
   {
    Relation catalog;

    catalog = table_open(classId, RowExclusiveLock);

    oldNspOid = AlterObjectNamespace_internal(catalog, objid,
                nspOid);

    table_close(catalog, RowExclusiveLock);
   }
   break;

  default:
   /* ignore object types that don't have schema-qualified names */
   Assert(get_object_attnum_namespace(classId) == InvalidAttrNumber);
 }

 return oldNspOid;
}

/*
 * Generic function to change the namespace of a given object, for simple
 * cases (won't work for tables, nor other cases where we need to do more
 * than change the namespace column of a single catalog entry).
 *
 * rel: catalog relation containing object (RowExclusiveLock'd by caller)
 * objid: OID of object to change the namespace of
 * nspOid: OID of new namespace
 *
 * Returns the OID of the object's previous namespace.
 */
static Oid
AlterObjectNamespace_internal(Relation rel, Oid objid, Oid nspOid)
{
 Oid   classId = RelationGetRelid(rel);
 int   oidCacheId = get_object_catcache_oid(classId);
 int   nameCacheId = get_object_catcache_name(classId);
 AttrNumber Anum_name = get_object_attnum_name(classId);
 AttrNumber Anum_namespace = get_object_attnum_namespace(classId);
 AttrNumber Anum_owner = get_object_attnum_owner(classId);
 Oid   oldNspOid;
 Datum  name,
    namespace;
 bool  isnull;
 HeapTuple tup,
    newtup;
 Datum    *values;
 bool    *nulls;
 bool    *replaces;

 tup = SearchSysCacheCopy1(oidCacheId, ObjectIdGetDatum(objid));
 if (!HeapTupleIsValid(tup)) /* should not happen */
  elog(ERROR, "cache lookup failed for object %u of catalog \"%s\"",
    objid, RelationGetRelationName(rel));

 name = heap_getattr(tup, Anum_name, RelationGetDescr(rel), &isnull);
 Assert(!isnull);
 namespace = heap_getattr(tup, Anum_namespace, RelationGetDescr(rel),
        &isnull);
 Assert(!isnull);
 oldNspOid = DatumGetObjectId(namespace);

 /*
  * If the object is already in the correct namespace, we don't need to do
  * anything except fire the object access hook.
 */
 if (oldNspOid == nspOid)
 {
  InvokeObjectPostAlterHook(classId, objid, 0);
  return oldNspOid;
 }

 /* Check basic namespace related issues */
 CheckSetNamespace(oldNspOid, nspOid);

 /* Permission checks ... superusers can always do it */
 if (!superuser())
 {
  Datum  owner;
  Oid   ownerId;
  AclResult aclresult;

  /* Fail if object does not have an explicit owner */
  if (Anum_owner <= 0)
   ereport(ERROR,
     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
      errmsg("must be superuser to set schema of %s",
       getObjectDescriptionOids(classId, objid))));

  /* Otherwise, must be owner of the existing object */
  owner = heap_getattr(tup, Anum_owner, RelationGetDescr(rel), &isnull);
  Assert(!isnull);
  ownerId = DatumGetObjectId(owner);

  if (!has_privs_of_role(GetUserId(), ownerId))
   aclcheck_error(ACLCHECK_NOT_OWNER, get_object_type(classId, objid),
         NameStr(*(DatumGetName(name))));

  /* User must have CREATE privilege on new namespace */
  aclresult = object_aclcheck(NamespaceRelationId, nspOid, GetUserId(), ACL_CREATE);
  if (aclresult != ACLCHECK_OK)
   aclcheck_error(aclresult, OBJECT_SCHEMA,
         get_namespace_name(nspOid));
 }

 /*
  * Check for duplicate name (more friendly than unique-index failure).
  * Since this is just a friendliness check, we can just skip it in cases
  * where there isn't suitable support.
 */
 if (classId == ProcedureRelationId)
 {
  Form_pg_proc proc = (Form_pg_proc) GETSTRUCT(tup);

  IsThereFunctionInNamespace(NameStr(proc->proname), proc->pronargs,
           &proc->proargtypes, nspOid);
 }
 else if (classId == CollationRelationId)
 {
  Form_pg_collation coll = (Form_pg_collation) GETSTRUCT(tup);

  IsThereCollationInNamespace(NameStr(coll->collname), nspOid);
 }
 else if (classId == OperatorClassRelationId)
 {
  Form_pg_opclass opc = (Form_pg_opclass) GETSTRUCT(tup);

  IsThereOpClassInNamespace(NameStr(opc->opcname),
          opc->opcmethod, nspOid);
 }
 else if (classId == OperatorFamilyRelationId)
 {
  Form_pg_opfamily opf = (Form_pg_opfamily) GETSTRUCT(tup);

  IsThereOpFamilyInNamespace(NameStr(opf->opfname),
           opf->opfmethod, nspOid);
 }
 else if (nameCacheId >= 0 &&
    SearchSysCacheExists2(nameCacheId, name,
           ObjectIdGetDatum(nspOid)))
  report_namespace_conflict(classId,
          NameStr(*(DatumGetName(name))),
          nspOid);

 /* Build modified tuple */
 values = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(Datum));
 nulls = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool));
 replaces = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool));
 values[Anum_namespace - 1] = ObjectIdGetDatum(nspOid);
 replaces[Anum_namespace - 1] = true;
 newtup = heap_modify_tuple(tup, RelationGetDescr(rel),
          values, nulls, replaces);

 /* Perform actual update */
 CatalogTupleUpdate(rel, &tup->t_self, newtup);

 /* Release memory */
 pfree(values);
 pfree(nulls);
 pfree(replaces);

 /* update dependency to point to the new schema */
 if (changeDependencyFor(classId, objid,
       NamespaceRelationId, oldNspOid, nspOid) != 1)
  elog(ERROR, "could not change schema dependency for object %u",
    objid);

 InvokeObjectPostAlterHook(classId, objid, 0);

 return oldNspOid;
}

/*
 * Executes an ALTER OBJECT / OWNER TO statement.  Based on the object
 * type, the function appropriate to that type is executed.
 */
ObjectAddress
ExecAlterOwnerStmt(AlterOwnerStmt *stmt)
{
 Oid   newowner = get_rolespec_oid(stmt->newowner, false);

 switch (stmt->objectType)
 {
  case OBJECT_DATABASE:
   return AlterDatabaseOwner(strVal(stmt->object), newowner);

  case OBJECT_SCHEMA:
   return AlterSchemaOwner(strVal(stmt->object), newowner);

  case OBJECT_TYPE:
  case OBJECT_DOMAIN:  /* same as TYPE */
   return AlterTypeOwner(castNode(List, stmt->object), newowner, stmt->objectType);
   break;

  case OBJECT_FDW:
   return AlterForeignDataWrapperOwner(strVal(stmt->object),
            newowner);

  case OBJECT_FOREIGN_SERVER:
   return AlterForeignServerOwner(strVal(stmt->object),
             newowner);

  case OBJECT_EVENT_TRIGGER:
   return AlterEventTriggerOwner(strVal(stmt->object),
            newowner);

  case OBJECT_PUBLICATION:
   return AlterPublicationOwner(strVal(stmt->object),
           newowner);

  case OBJECT_SUBSCRIPTION:
   return AlterSubscriptionOwner(strVal(stmt->object),
            newowner);

   /* Generic cases */
  case OBJECT_AGGREGATE:
  case OBJECT_COLLATION:
  case OBJECT_CONVERSION:
  case OBJECT_FUNCTION:
  case OBJECT_LANGUAGE:
  case OBJECT_LARGEOBJECT:
  case OBJECT_OPERATOR:
  case OBJECT_OPCLASS:
  case OBJECT_OPFAMILY:
  case OBJECT_PROCEDURE:
  case OBJECT_ROUTINE:
  case OBJECT_STATISTIC_EXT:
  case OBJECT_TABLESPACE:
  case OBJECT_TSDICTIONARY:
  case OBJECT_TSCONFIGURATION:
   {
    ObjectAddress address;

    address = get_object_address(stmt->objectType,
            stmt->object,
            NULL,
            AccessExclusiveLock,
            false);

    AlterObjectOwner_internal(address.classId, address.objectId,
            newowner);

    return address;
   }
   break;

  default:
   elog(ERROR, "unrecognized AlterOwnerStmt type: %d",
     (int) stmt->objectType);
   return InvalidObjectAddress; /* keep compiler happy */
 }
}

/*
 * Generic function to change the ownership of a given object, for simple
 * cases (won't work for tables, nor other cases where we need to do more than
 * change the ownership column of a single catalog entry).
 *
 * classId: OID of catalog containing object
 * objectId: OID of object to change the ownership of
 * new_ownerId: OID of new object owner
 *
 * This will work on large objects, but we have to beware of the fact that
 * classId isn't the OID of the catalog to modify in that case.
 */
void
AlterObjectOwner_internal(Oid classId, Oid objectId, Oid new_ownerId)
{
 /* For large objects, the catalog to modify is pg_largeobject_metadata */
 Oid   catalogId = (classId == LargeObjectRelationId) ? LargeObjectMetadataRelationId : classId;
 AttrNumber Anum_oid = get_object_attnum_oid(catalogId);
 AttrNumber Anum_owner = get_object_attnum_owner(catalogId);
 AttrNumber Anum_namespace = get_object_attnum_namespace(catalogId);
 AttrNumber Anum_acl = get_object_attnum_acl(catalogId);
 AttrNumber Anum_name = get_object_attnum_name(catalogId);
 Relation rel;
 HeapTuple oldtup;
 Datum  datum;
 bool  isnull;
 Oid   old_ownerId;
 Oid   namespaceId = InvalidOid;

 rel = table_open(catalogId, RowExclusiveLock);

 /* Search tuple and lock it. */
 oldtup =
  get_catalog_object_by_oid_extended(rel, Anum_oid, objectId, true);
 if (oldtup == NULL)
  elog(ERROR, "cache lookup failed for object %u of catalog \"%s\"",
    objectId, RelationGetRelationName(rel));

 datum = heap_getattr(oldtup, Anum_owner,
       RelationGetDescr(rel), &isnull);
 Assert(!isnull);
 old_ownerId = DatumGetObjectId(datum);

 if (Anum_namespace != InvalidAttrNumber)
 {
  datum = heap_getattr(oldtup, Anum_namespace,
        RelationGetDescr(rel), &isnull);
  Assert(!isnull);
  namespaceId = DatumGetObjectId(datum);
 }

 if (old_ownerId != new_ownerId)
 {
  AttrNumber nattrs;
  HeapTuple newtup;
  Datum    *values;
  bool    *nulls;
  bool    *replaces;

  /* Superusers can bypass permission checks */
  if (!superuser())
  {
   /* must be owner */
   if (!has_privs_of_role(GetUserId(), old_ownerId))
   {
    char    *objname;
    char  namebuf[NAMEDATALEN];

    if (Anum_name != InvalidAttrNumber)
    {
     datum = heap_getattr(oldtup, Anum_name,
           RelationGetDescr(rel), &isnull);
     Assert(!isnull);
     objname = NameStr(*DatumGetName(datum));
    }
    else
    {
     snprintf(namebuf, sizeof(namebuf), "%u", objectId);
     objname = namebuf;
    }
    aclcheck_error(ACLCHECK_NOT_OWNER,
          get_object_type(catalogId, objectId),
          objname);
   }
   /* Must be able to become new owner */
   check_can_set_role(GetUserId(), new_ownerId);

   /* New owner must have CREATE privilege on namespace */
   if (OidIsValid(namespaceId))
   {
    AclResult aclresult;

    aclresult = object_aclcheck(NamespaceRelationId, namespaceId, new_ownerId,
           ACL_CREATE);
    if (aclresult != ACLCHECK_OK)
     aclcheck_error(aclresult, OBJECT_SCHEMA,
           get_namespace_name(namespaceId));
   }
  }

  /* Build a modified tuple */
  nattrs = RelationGetNumberOfAttributes(rel);
  values = palloc0(nattrs * sizeof(Datum));
  nulls = palloc0(nattrs * sizeof(bool));
  replaces = palloc0(nattrs * sizeof(bool));
  values[Anum_owner - 1] = ObjectIdGetDatum(new_ownerId);
  replaces[Anum_owner - 1] = true;

  /*
   * Determine the modified ACL for the new owner.  This is only
   * necessary when the ACL is non-null.
 */
  if (Anum_acl != InvalidAttrNumber)
  {
   datum = heap_getattr(oldtup,
         Anum_acl, RelationGetDescr(rel), &isnull);
   if (!isnull)
   {
    Acl     *newAcl;

    newAcl = aclnewowner(DatumGetAclP(datum),
          old_ownerId, new_ownerId);
    values[Anum_acl - 1] = PointerGetDatum(newAcl);
    replaces[Anum_acl - 1] = true;
   }
  }

  newtup = heap_modify_tuple(oldtup, RelationGetDescr(rel),
           values, nulls, replaces);

  /* Perform actual update */
  CatalogTupleUpdate(rel, &newtup->t_self, newtup);

  UnlockTuple(rel, &oldtup->t_self, InplaceUpdateTupleLock);

  /* Update owner dependency reference */
  changeDependencyOnOwner(classId, objectId, new_ownerId);

  /* Release memory */
  pfree(values);
  pfree(nulls);
  pfree(replaces);
 }
 else
  UnlockTuple(rel, &oldtup->t_self, InplaceUpdateTupleLock);

 /* Note the post-alter hook gets classId not catalogId */
 InvokeObjectPostAlterHook(classId, objectId, 0);

 table_close(rel, RowExclusiveLock);
}