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 692 of file alter.c.

{
    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;
}

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 625 of file alter.c.

{
    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;
}

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 926 of file alter.c.

{
    /* 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);
}

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.

{
    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);
}

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, InvalidatePubRelSyncCache(), 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 471 of file alter.c.

{
    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;
}

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 534 of file alter.c.

{
    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;
}

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 837 of file alter.c.

{
    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 */
    }
}

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 373 of file alter.c.

{
    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 */
    }
}

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.

{
    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)));
}

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.

{
    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))));
}

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