cluster.h File Reference

#include "nodes/parsenodes.h"
#include "parser/parse_node.h"
#include "storage/lock.h"
#include "utils/relcache.h"

Include dependency graph for cluster.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ClusterParams

Macros
#define	CLUOPT_VERBOSE   0x01 /* print progress info */
#define	CLUOPT_RECHECK   0x02 /* recheck relation state */
#define	CLUOPT_RECHECK_ISCLUSTERED
#define	CLUOPT_ANALYZE   0x08 /* do an ANALYZE */

Typedefs
typedef struct ClusterParams	ClusterParams

Functions
void	ExecRepack (ParseState *pstate, RepackStmt *stmt, bool isTopLevel)
void	cluster_rel (RepackCommand command, Relation OldHeap, Oid indexOid, ClusterParams *params)
void	check_index_is_clusterable (Relation OldHeap, Oid indexOid, LOCKMODE lockmode)
void	mark_index_clustered (Relation rel, Oid indexOid, bool is_internal)
Oid	make_new_heap (Oid OIDOldHeap, Oid NewTableSpace, Oid NewAccessMethod, char relpersistence, LOCKMODE lockmode)
void	finish_heap_swap (Oid OIDOldHeap, Oid OIDNewHeap, bool is_system_catalog, bool swap_toast_by_content, bool check_constraints, bool is_internal, TransactionId frozenXid, MultiXactId cutoffMulti, char newrelpersistence)

Macro Definition Documentation

CLUOPT_ANALYZE

#define CLUOPT_ANALYZE   0x08 /* do an ANALYZE */

Definition at line 26 of file cluster.h.

CLUOPT_RECHECK

#define CLUOPT_RECHECK   0x02 /* recheck relation state */

Definition at line 24 of file cluster.h.

CLUOPT_RECHECK_ISCLUSTERED

#define CLUOPT_RECHECK_ISCLUSTERED

Value:

                                         0x04 /* recheck relation state for
                                         * indisclustered */

Definition at line 25 of file cluster.h.

{
    bits32      options;        /* bitmask of CLUOPT_* */
} ClusterParams;
 
 
extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel);
 
extern void cluster_rel(RepackCommand command, Relation OldHeap, Oid indexOid,
                        ClusterParams *params);
extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
                                       LOCKMODE lockmode);
extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
 
extern Oid  make_new_heap(Oid OIDOldHeap, Oid NewTableSpace, Oid NewAccessMethod,
                          char relpersistence, LOCKMODE lockmode);
extern void finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
                             bool is_system_catalog,
                             bool swap_toast_by_content,
                             bool check_constraints,
                             bool is_internal,
                             TransactionId frozenXid,
                             MultiXactId cutoffMulti,
                             char newrelpersistence);
 
#endif                          /* CLUSTER_H */

CLUOPT_VERBOSE

#define CLUOPT_VERBOSE   0x01 /* print progress info */

Definition at line 23 of file cluster.h.

Typedef Documentation

ClusterParams

typedef struct ClusterParams ClusterParams

Function Documentation

check_index_is_clusterable()

void check_index_is_clusterable ( Relation  OldHeap, Oid  indexOid, LOCKMODE  lockmode  )

extern

Definition at line 508 of file cluster.c.

{
    Relation    OldIndex;
 
    OldIndex = index_open(indexOid, lockmode);
 
    /*
     * Check that index is in fact an index on the given relation
     */
    if (OldIndex->rd_index == NULL ||
        OldIndex->rd_index->indrelid != RelationGetRelid(OldHeap))
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("\"%s\" is not an index for table \"%s\"",
                        RelationGetRelationName(OldIndex),
                        RelationGetRelationName(OldHeap))));
 
    /* Index AM must allow clustering */
    if (!OldIndex->rd_indam->amclusterable)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot cluster on index \"%s\" because access method does not support clustering",
                        RelationGetRelationName(OldIndex))));
 
    /*
     * Disallow clustering on incomplete indexes (those that might not index
     * every row of the relation).  We could relax this by making a separate
     * seqscan pass over the table to copy the missing rows, but that seems
     * expensive and tedious.
     */
    if (!heap_attisnull(OldIndex->rd_indextuple, Anum_pg_index_indpred, NULL))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot cluster on partial index \"%s\"",
                        RelationGetRelationName(OldIndex))));
 
    /*
     * Disallow if index is left over from a failed CREATE INDEX CONCURRENTLY;
     * it might well not contain entries for every heap row, or might not even
     * be internally consistent.  (But note that we don't check indcheckxmin;
     * the worst consequence of following broken HOT chains would be that we
     * might put recently-dead tuples out-of-order in the new table, and there
     * is little harm in that.)
     */
    if (!OldIndex->rd_index->indisvalid)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot cluster on invalid index \"%s\"",
                        RelationGetRelationName(OldIndex))));
 
    /* Drop relcache refcnt on OldIndex, but keep lock */
    index_close(OldIndex, NoLock);
}

References ereport, errcode(), errmsg, ERROR, fb(), heap_attisnull(), index_close(), index_open(), NoLock, RelationGetRelationName, and RelationGetRelid.

Referenced by ATExecClusterOn(), cluster_rel(), ExecRepack(), and process_single_relation().

cluster_rel()

void cluster_rel ( RepackCommand  command, Relation  OldHeap, Oid  indexOid, ClusterParams *  params  )

extern

Definition at line 300 of file cluster.c.

{
    Oid         tableOid = RelationGetRelid(OldHeap);
    Oid         save_userid;
    int         save_sec_context;
    int         save_nestlevel;
    bool        verbose = ((params->options & CLUOPT_VERBOSE) != 0);
    bool        recheck = ((params->options & CLUOPT_RECHECK) != 0);
    Relation    index;
 
    Assert(CheckRelationLockedByMe(OldHeap, AccessExclusiveLock, false));
 
    /* Check for user-requested abort. */
    CHECK_FOR_INTERRUPTS();
 
    pgstat_progress_start_command(PROGRESS_COMMAND_REPACK, tableOid);
    pgstat_progress_update_param(PROGRESS_REPACK_COMMAND, cmd);
 
    /*
     * Switch to the table owner's userid, so that any index functions are run
     * as that user.  Also lock down security-restricted operations and
     * arrange to make GUC variable changes local to this command.
     */
    GetUserIdAndSecContext(&save_userid, &save_sec_context);
    SetUserIdAndSecContext(OldHeap->rd_rel->relowner,
                           save_sec_context | SECURITY_RESTRICTED_OPERATION);
    save_nestlevel = NewGUCNestLevel();
    RestrictSearchPath();
 
    /*
     * Since we may open a new transaction for each relation, we have to check
     * that the relation still is what we think it is.
     *
     * If this is a single-transaction CLUSTER, we can skip these tests. We
     * *must* skip the one on indisclustered since it would reject an attempt
     * to cluster a not-previously-clustered index.
     */
    if (recheck &&
        !cluster_rel_recheck(cmd, OldHeap, indexOid, save_userid,
                             params->options))
        goto out;
 
    /*
     * We allow repacking shared catalogs only when not using an index. It
     * would work to use an index in most respects, but the index would only
     * get marked as indisclustered in the current database, leading to
     * unexpected behavior if CLUSTER were later invoked in another database.
     */
    if (OidIsValid(indexOid) && OldHeap->rd_rel->relisshared)
        ereport(ERROR,
                errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*- translator: first %s is name of a SQL command, eg. REPACK */
                errmsg("cannot execute %s on a shared catalog",
                       RepackCommandAsString(cmd)));
 
    /*
     * Don't process temp tables of other backends ... their local buffer
     * manager is not going to cope.
     */
    if (RELATION_IS_OTHER_TEMP(OldHeap))
        ereport(ERROR,
                errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*- translator: first %s is name of a SQL command, eg. REPACK */
                errmsg("cannot execute %s on temporary tables of other sessions",
                       RepackCommandAsString(cmd)));
 
    /*
     * Also check for active uses of the relation in the current transaction,
     * including open scans and pending AFTER trigger events.
     */
    CheckTableNotInUse(OldHeap, RepackCommandAsString(cmd));
 
    /* Check heap and index are valid to cluster on */
    if (OidIsValid(indexOid))
    {
        /* verify the index is good and lock it */
        check_index_is_clusterable(OldHeap, indexOid, AccessExclusiveLock);
        /* also open it */
        index = index_open(indexOid, NoLock);
    }
    else
        index = NULL;
 
    /*
     * When allow_system_table_mods is turned off, we disallow repacking a
     * catalog on a particular index unless that's already the clustered index
     * for that catalog.
     *
     * XXX We don't check for this in CLUSTER, because it's historically been
     * allowed.
     */
    if (cmd != REPACK_COMMAND_CLUSTER &&
        !allowSystemTableMods && OidIsValid(indexOid) &&
        IsCatalogRelation(OldHeap) && !index->rd_index->indisclustered)
        ereport(ERROR,
                errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                errmsg("permission denied: \"%s\" is a system catalog",
                       RelationGetRelationName(OldHeap)),
                errdetail("System catalogs can only be clustered by the index they're already clustered on, if any, unless \"%s\" is enabled.",
                          "allow_system_table_mods"));
 
    /*
     * Quietly ignore the request if this is a materialized view which has not
     * been populated from its query. No harm is done because there is no data
     * to deal with, and we don't want to throw an error if this is part of a
     * multi-relation request -- for example, CLUSTER was run on the entire
     * database.
     */
    if (OldHeap->rd_rel->relkind == RELKIND_MATVIEW &&
        !RelationIsPopulated(OldHeap))
    {
        relation_close(OldHeap, AccessExclusiveLock);
        goto out;
    }
 
    Assert(OldHeap->rd_rel->relkind == RELKIND_RELATION ||
           OldHeap->rd_rel->relkind == RELKIND_MATVIEW ||
           OldHeap->rd_rel->relkind == RELKIND_TOASTVALUE);
 
    /*
     * All predicate locks on the tuples or pages are about to be made
     * invalid, because we move tuples around.  Promote them to relation
     * locks.  Predicate locks on indexes will be promoted when they are
     * reindexed.
     */
    TransferPredicateLocksToHeapRelation(OldHeap);
 
    /* rebuild_relation does all the dirty work */
    rebuild_relation(OldHeap, index, verbose);
    /* rebuild_relation closes OldHeap, and index if valid */
 
out:
    /* Roll back any GUC changes executed by index functions */
    AtEOXact_GUC(false, save_nestlevel);
 
    /* Restore userid and security context */
    SetUserIdAndSecContext(save_userid, save_sec_context);
 
    pgstat_progress_end_command();
}

References AccessExclusiveLock, allowSystemTableMods, Assert, AtEOXact_GUC(), CHECK_FOR_INTERRUPTS, check_index_is_clusterable(), CheckRelationLockedByMe(), CheckTableNotInUse(), CLUOPT_RECHECK, CLUOPT_VERBOSE, cluster_rel_recheck(), ereport, errcode(), errdetail(), errmsg, ERROR, fb(), GetUserIdAndSecContext(), index_open(), IsCatalogRelation(), NewGUCNestLevel(), NoLock, OidIsValid, ClusterParams::options, pgstat_progress_end_command(), pgstat_progress_start_command(), pgstat_progress_update_param(), PROGRESS_COMMAND_REPACK, PROGRESS_REPACK_COMMAND, rebuild_relation(), relation_close(), RELATION_IS_OTHER_TEMP, RelationGetRelationName, RelationGetRelid, RelationIsPopulated, REPACK_COMMAND_CLUSTER, RepackCommandAsString(), RestrictSearchPath(), SECURITY_RESTRICTED_OPERATION, SetUserIdAndSecContext(), TransferPredicateLocksToHeapRelation(), and verbose.

Referenced by ExecRepack(), process_single_relation(), and vacuum_rel().

ExecRepack()

void ExecRepack ( ParseState *  pstate, RepackStmt *  stmt, bool  isTopLevel  )

extern

Definition at line 113 of file cluster.c.

{
    ClusterParams params = {0};
    Relation    rel = NULL;
    MemoryContext repack_context;
    List       *rtcs;
 
    /* Parse option list */
    foreach_node(DefElem, opt, stmt->params)
    {
        if (strcmp(opt->defname, "verbose") == 0)
            params.options |= defGetBoolean(opt) ? CLUOPT_VERBOSE : 0;
        else if (strcmp(opt->defname, "analyze") == 0 ||
                 strcmp(opt->defname, "analyse") == 0)
            params.options |= defGetBoolean(opt) ? CLUOPT_ANALYZE : 0;
        else
            ereport(ERROR,
                    errcode(ERRCODE_SYNTAX_ERROR),
                    errmsg("unrecognized %s option \"%s\"",
                           RepackCommandAsString(stmt->command),
                           opt->defname),
                    parser_errposition(pstate, opt->location));
    }
 
    /*
     * If a single relation is specified, process it and we're done ... unless
     * the relation is a partitioned table, in which case we fall through.
     */
    if (stmt->relation != NULL)
    {
        rel = process_single_relation(stmt, &params);
        if (rel == NULL)
            return;             /* all done */
    }
 
    /*
     * Don't allow ANALYZE in the multiple-relation case for now.  Maybe we
     * can add support for this later.
     */
    if (params.options & CLUOPT_ANALYZE)
        ereport(ERROR,
                errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                errmsg("cannot execute %s on multiple tables",
                       "REPACK (ANALYZE)"));
 
    /*
     * By here, we know we are in a multi-table situation.  In order to avoid
     * holding locks for too long, we want to process each table in its own
     * transaction.  This forces us to disallow running inside a user
     * transaction block.
     */
    PreventInTransactionBlock(isTopLevel, RepackCommandAsString(stmt->command));
 
    /* Also, we need a memory context to hold our list of relations */
    repack_context = AllocSetContextCreate(PortalContext,
                                           "Repack",
                                           ALLOCSET_DEFAULT_SIZES);
 
    params.options |= CLUOPT_RECHECK;
 
    /*
     * If we don't have a relation yet, determine a relation list.  If we do,
     * then it must be a partitioned table, and we want to process its
     * partitions.
     */
    if (rel == NULL)
    {
        Assert(stmt->indexname == NULL);
        rtcs = get_tables_to_repack(stmt->command, stmt->usingindex,
                                    repack_context);
        params.options |= CLUOPT_RECHECK_ISCLUSTERED;
    }
    else
    {
        Oid         relid;
        bool        rel_is_index;
 
        Assert(rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
        /*
         * If USING INDEX was specified, resolve the index name now and pass
         * it down.
         */
        if (stmt->usingindex)
        {
            /*
             * If no index name was specified when repacking a partitioned
             * table, punt for now.  Maybe we can improve this later.
             */
            if (!stmt->indexname)
            {
                if (stmt->command == REPACK_COMMAND_CLUSTER)
                    ereport(ERROR,
                            errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                            errmsg("there is no previously clustered index for table \"%s\"",
                                   RelationGetRelationName(rel)));
                else
                    ereport(ERROR,
                            errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                    /*- translator: first %s is name of a SQL command, eg. REPACK */
                            errmsg("cannot execute %s on partitioned table \"%s\" USING INDEX with no index name",
                                   RepackCommandAsString(stmt->command),
                                   RelationGetRelationName(rel)));
            }
 
            relid = determine_clustered_index(rel, stmt->usingindex,
                                              stmt->indexname);
            if (!OidIsValid(relid))
                elog(ERROR, "unable to determine index to cluster on");
            check_index_is_clusterable(rel, relid, AccessExclusiveLock);
 
            rel_is_index = true;
        }
        else
        {
            relid = RelationGetRelid(rel);
            rel_is_index = false;
        }
 
        rtcs = get_tables_to_repack_partitioned(stmt->command,
                                                relid, rel_is_index,
                                                repack_context);
 
        /* close parent relation, releasing lock on it */
        table_close(rel, AccessExclusiveLock);
        rel = NULL;
    }
 
    /* Commit to get out of starting transaction */
    PopActiveSnapshot();
    CommitTransactionCommand();
 
    /* Cluster the tables, each in a separate transaction */
    Assert(rel == NULL);
    foreach_ptr(RelToCluster, rtc, rtcs)
    {
        /* Start a new transaction for each relation. */
        StartTransactionCommand();
 
        /*
         * Open the target table, coping with the case where it has been
         * dropped.
         */
        rel = try_table_open(rtc->tableOid, AccessExclusiveLock);
        if (rel == NULL)
        {
            CommitTransactionCommand();
            continue;
        }
 
        /* functions in indexes may want a snapshot set */
        PushActiveSnapshot(GetTransactionSnapshot());
 
        /* Process this table */
        cluster_rel(stmt->command, rel, rtc->indexOid, &params);
        /* cluster_rel closes the relation, but keeps lock */
 
        PopActiveSnapshot();
        CommitTransactionCommand();
    }
 
    /* Start a new transaction for the cleanup work. */
    StartTransactionCommand();
 
    /* Clean up working storage */
    MemoryContextDelete(repack_context);
}

References AccessExclusiveLock, ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, check_index_is_clusterable(), CLUOPT_ANALYZE, CLUOPT_RECHECK, CLUOPT_RECHECK_ISCLUSTERED, CLUOPT_VERBOSE, cluster_rel(), CommitTransactionCommand(), defGetBoolean(), determine_clustered_index(), elog, ereport, errcode(), errmsg, ERROR, fb(), foreach_node, foreach_ptr, get_tables_to_repack(), get_tables_to_repack_partitioned(), GetTransactionSnapshot(), MemoryContextDelete(), OidIsValid, ClusterParams::options, parser_errposition(), PopActiveSnapshot(), PortalContext, PreventInTransactionBlock(), process_single_relation(), PushActiveSnapshot(), RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, REPACK_COMMAND_CLUSTER, RepackCommandAsString(), StartTransactionCommand(), stmt, table_close(), and try_table_open().

Referenced by standard_ProcessUtility().

finish_heap_swap()

void finish_heap_swap ( Oid  OIDOldHeap, Oid  OIDNewHeap, bool  is_system_catalog, bool  swap_toast_by_content, bool  check_constraints, bool  is_internal, TransactionId  frozenXid, MultiXactId  cutoffMulti, char  newrelpersistence  )

extern

Definition at line 1459 of file cluster.c.

{
    ObjectAddress object;
    Oid         mapped_tables[4];
    int         reindex_flags;
    ReindexParams reindex_params = {0};
    int         i;
 
    /* Report that we are now swapping relation files */
    pgstat_progress_update_param(PROGRESS_REPACK_PHASE,
                                 PROGRESS_REPACK_PHASE_SWAP_REL_FILES);
 
    /* Zero out possible results from swapped_relation_files */
    memset(mapped_tables, 0, sizeof(mapped_tables));
 
    /*
     * Swap the contents of the heap relations (including any toast tables).
     * Also set old heap's relfrozenxid to frozenXid.
     */
    swap_relation_files(OIDOldHeap, OIDNewHeap,
                        (OIDOldHeap == RelationRelationId),
                        swap_toast_by_content, is_internal,
                        frozenXid, cutoffMulti, mapped_tables);
 
    /*
     * If it's a system catalog, queue a sinval message to flush all catcaches
     * on the catalog when we reach CommandCounterIncrement.
     */
    if (is_system_catalog)
        CacheInvalidateCatalog(OIDOldHeap);
 
    /*
     * Rebuild each index on the relation (but not the toast table, which is
     * all-new at this point).  It is important to do this before the DROP
     * step because if we are processing a system catalog that will be used
     * during DROP, we want to have its indexes available.  There is no
     * advantage to the other order anyway because this is all transactional,
     * so no chance to reclaim disk space before commit.  We do not need a
     * final CommandCounterIncrement() because reindex_relation does it.
     *
     * Note: because index_build is called via reindex_relation, it will never
     * set indcheckxmin true for the indexes.  This is OK even though in some
     * sense we are building new indexes rather than rebuilding existing ones,
     * because the new heap won't contain any HOT chains at all, let alone
     * broken ones, so it can't be necessary to set indcheckxmin.
     */
    reindex_flags = REINDEX_REL_SUPPRESS_INDEX_USE;
    if (check_constraints)
        reindex_flags |= REINDEX_REL_CHECK_CONSTRAINTS;
 
    /*
     * Ensure that the indexes have the same persistence as the parent
     * relation.
     */
    if (newrelpersistence == RELPERSISTENCE_UNLOGGED)
        reindex_flags |= REINDEX_REL_FORCE_INDEXES_UNLOGGED;
    else if (newrelpersistence == RELPERSISTENCE_PERMANENT)
        reindex_flags |= REINDEX_REL_FORCE_INDEXES_PERMANENT;
 
    /* Report that we are now reindexing relations */
    pgstat_progress_update_param(PROGRESS_REPACK_PHASE,
                                 PROGRESS_REPACK_PHASE_REBUILD_INDEX);
 
    reindex_relation(NULL, OIDOldHeap, reindex_flags, &reindex_params);
 
    /* Report that we are now doing clean up */
    pgstat_progress_update_param(PROGRESS_REPACK_PHASE,
                                 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
    /*
     * If the relation being rebuilt is pg_class, swap_relation_files()
     * couldn't update pg_class's own pg_class entry (check comments in
     * swap_relation_files()), thus relfrozenxid was not updated. That's
     * annoying because a potential reason for doing a VACUUM FULL is a
     * imminent or actual anti-wraparound shutdown.  So, now that we can
     * access the new relation using its indices, update relfrozenxid.
     * pg_class doesn't have a toast relation, so we don't need to update the
     * corresponding toast relation. Not that there's little point moving all
     * relfrozenxid updates here since swap_relation_files() needs to write to
     * pg_class for non-mapped relations anyway.
     */
    if (OIDOldHeap == RelationRelationId)
    {
        Relation    relRelation;
        HeapTuple   reltup;
        Form_pg_class relform;
 
        relRelation = table_open(RelationRelationId, RowExclusiveLock);
 
        reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
        if (!HeapTupleIsValid(reltup))
            elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
        relform = (Form_pg_class) GETSTRUCT(reltup);
 
        relform->relfrozenxid = frozenXid;
        relform->relminmxid = cutoffMulti;
 
        CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
 
        table_close(relRelation, RowExclusiveLock);
    }
 
    /* Destroy new heap with old filenumber */
    object.classId = RelationRelationId;
    object.objectId = OIDNewHeap;
    object.objectSubId = 0;
 
    /*
     * The new relation is local to our transaction and we know nothing
     * depends on it, so DROP_RESTRICT should be OK.
     */
    performDeletion(&object, DROP_RESTRICT, PERFORM_DELETION_INTERNAL);
 
    /* performDeletion does CommandCounterIncrement at end */
 
    /*
     * Now we must remove any relation mapping entries that we set up for the
     * transient table, as well as its toast table and toast index if any. If
     * we fail to do this before commit, the relmapper will complain about new
     * permanent map entries being added post-bootstrap.
     */
    for (i = 0; OidIsValid(mapped_tables[i]); i++)
        RelationMapRemoveMapping(mapped_tables[i]);
 
    /*
     * At this point, everything is kosher except that, if we did toast swap
     * by links, the toast table's name corresponds to the transient table.
     * The name is irrelevant to the backend because it's referenced by OID,
     * but users looking at the catalogs could be confused.  Rename it to
     * prevent this problem.
     *
     * Note no lock required on the relation, because we already hold an
     * exclusive lock on it.
     */
    if (!swap_toast_by_content)
    {
        Relation    newrel;
 
        newrel = table_open(OIDOldHeap, NoLock);
        if (OidIsValid(newrel->rd_rel->reltoastrelid))
        {
            Oid         toastidx;
            char        NewToastName[NAMEDATALEN];
 
            /* Get the associated valid index to be renamed */
            toastidx = toast_get_valid_index(newrel->rd_rel->reltoastrelid,
                                             NoLock);
 
            /* rename the toast table ... */
            snprintf(NewToastName, NAMEDATALEN, "pg_toast_%u",
                     OIDOldHeap);
            RenameRelationInternal(newrel->rd_rel->reltoastrelid,
                                   NewToastName, true, false);
 
            /* ... and its valid index too. */
            snprintf(NewToastName, NAMEDATALEN, "pg_toast_%u_index",
                     OIDOldHeap);
 
            RenameRelationInternal(toastidx,
                                   NewToastName, true, true);
 
            /*
             * Reset the relrewrite for the toast. The command-counter
             * increment is required here as we are about to update the tuple
             * that is updated as part of RenameRelationInternal.
             */
            CommandCounterIncrement();
            ResetRelRewrite(newrel->rd_rel->reltoastrelid);
        }
        relation_close(newrel, NoLock);
    }
 
    /* if it's not a catalog table, clear any missing attribute settings */
    if (!is_system_catalog)
    {
        Relation    newrel;
 
        newrel = table_open(OIDOldHeap, NoLock);
        RelationClearMissing(newrel);
        relation_close(newrel, NoLock);
    }
}

References CacheInvalidateCatalog(), CatalogTupleUpdate(), CommandCounterIncrement(), DROP_RESTRICT, elog, ERROR, fb(), GETSTRUCT(), HeapTupleIsValid, i, NAMEDATALEN, NoLock, ObjectIdGetDatum(), OidIsValid, PERFORM_DELETION_INTERNAL, performDeletion(), pgstat_progress_update_param(), PROGRESS_REPACK_PHASE, PROGRESS_REPACK_PHASE_FINAL_CLEANUP, PROGRESS_REPACK_PHASE_REBUILD_INDEX, PROGRESS_REPACK_PHASE_SWAP_REL_FILES, REINDEX_REL_CHECK_CONSTRAINTS, REINDEX_REL_FORCE_INDEXES_PERMANENT, REINDEX_REL_FORCE_INDEXES_UNLOGGED, REINDEX_REL_SUPPRESS_INDEX_USE, reindex_relation(), relation_close(), RelationClearMissing(), RelationMapRemoveMapping(), RenameRelationInternal(), ResetRelRewrite(), RowExclusiveLock, SearchSysCacheCopy1, snprintf, swap_relation_files(), table_close(), table_open(), and toast_get_valid_index().

Referenced by ATRewriteTables(), rebuild_relation(), and refresh_by_heap_swap().

make_new_heap()

Oid make_new_heap ( Oid  OIDOldHeap, Oid  NewTableSpace, Oid  NewAccessMethod, char  relpersistence, LOCKMODE  lockmode  )

extern

Definition at line 719 of file cluster.c.

{
    TupleDesc   OldHeapDesc;
    char        NewHeapName[NAMEDATALEN];
    Oid         OIDNewHeap;
    Oid         toastid;
    Relation    OldHeap;
    HeapTuple   tuple;
    Datum       reloptions;
    bool        isNull;
    Oid         namespaceid;
 
    OldHeap = table_open(OIDOldHeap, lockmode);
    OldHeapDesc = RelationGetDescr(OldHeap);
 
    /*
     * Note that the NewHeap will not receive any of the defaults or
     * constraints associated with the OldHeap; we don't need 'em, and there's
     * no reason to spend cycles inserting them into the catalogs only to
     * delete them.
     */
 
    /*
     * But we do want to use reloptions of the old heap for new heap.
     */
    tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(OIDOldHeap));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
    reloptions = SysCacheGetAttr(RELOID, tuple, Anum_pg_class_reloptions,
                                 &isNull);
    if (isNull)
        reloptions = (Datum) 0;
 
    if (relpersistence == RELPERSISTENCE_TEMP)
        namespaceid = LookupCreationNamespace("pg_temp");
    else
        namespaceid = RelationGetNamespace(OldHeap);
 
    /*
     * Create the new heap, using a temporary name in the same namespace as
     * the existing table.  NOTE: there is some risk of collision with user
     * relnames.  Working around this seems more trouble than it's worth; in
     * particular, we can't create the new heap in a different namespace from
     * the old, or we will have problems with the TEMP status of temp tables.
     *
     * Note: the new heap is not a shared relation, even if we are rebuilding
     * a shared rel.  However, we do make the new heap mapped if the source is
     * mapped.  This simplifies swap_relation_files, and is absolutely
     * necessary for rebuilding pg_class, for reasons explained there.
     */
    snprintf(NewHeapName, sizeof(NewHeapName), "pg_temp_%u", OIDOldHeap);
 
    OIDNewHeap = heap_create_with_catalog(NewHeapName,
                                          namespaceid,
                                          NewTableSpace,
                                          InvalidOid,
                                          InvalidOid,
                                          InvalidOid,
                                          OldHeap->rd_rel->relowner,
                                          NewAccessMethod,
                                          OldHeapDesc,
                                          NIL,
                                          RELKIND_RELATION,
                                          relpersistence,
                                          false,
                                          RelationIsMapped(OldHeap),
                                          ONCOMMIT_NOOP,
                                          reloptions,
                                          false,
                                          true,
                                          true,
                                          OIDOldHeap,
                                          NULL);
    Assert(OIDNewHeap != InvalidOid);
 
    ReleaseSysCache(tuple);
 
    /*
     * Advance command counter so that the newly-created relation's catalog
     * tuples will be visible to table_open.
     */
    CommandCounterIncrement();
 
    /*
     * If necessary, create a TOAST table for the new relation.
     *
     * If the relation doesn't have a TOAST table already, we can't need one
     * for the new relation.  The other way around is possible though: if some
     * wide columns have been dropped, NewHeapCreateToastTable can decide that
     * no TOAST table is needed for the new table.
     *
     * Note that NewHeapCreateToastTable ends with CommandCounterIncrement, so
     * that the TOAST table will be visible for insertion.
     */
    toastid = OldHeap->rd_rel->reltoastrelid;
    if (OidIsValid(toastid))
    {
        /* keep the existing toast table's reloptions, if any */
        tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(toastid));
        if (!HeapTupleIsValid(tuple))
            elog(ERROR, "cache lookup failed for relation %u", toastid);
        reloptions = SysCacheGetAttr(RELOID, tuple, Anum_pg_class_reloptions,
                                     &isNull);
        if (isNull)
            reloptions = (Datum) 0;
 
        NewHeapCreateToastTable(OIDNewHeap, reloptions, lockmode, toastid);
 
        ReleaseSysCache(tuple);
    }
 
    table_close(OldHeap, NoLock);
 
    return OIDNewHeap;
}

References Assert, CommandCounterIncrement(), elog, ERROR, fb(), heap_create_with_catalog(), HeapTupleIsValid, InvalidOid, LookupCreationNamespace(), NAMEDATALEN, NewHeapCreateToastTable(), NIL, NoLock, ObjectIdGetDatum(), OidIsValid, ONCOMMIT_NOOP, RelationGetDescr, RelationGetNamespace, RelationIsMapped, ReleaseSysCache(), SearchSysCache1(), snprintf, SysCacheGetAttr(), table_close(), and table_open().

Referenced by ATRewriteTables(), rebuild_relation(), and RefreshMatViewByOid().

mark_index_clustered()

void mark_index_clustered ( Relation  rel, Oid  indexOid, bool  is_internal  )

extern

Definition at line 568 of file cluster.c.

{
    HeapTuple   indexTuple;
    Form_pg_index indexForm;
    Relation    pg_index;
    ListCell   *index;
 
    /* Disallow applying to a partitioned table */
    if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot mark index clustered in partitioned table")));
 
    /*
     * If the index is already marked clustered, no need to do anything.
     */
    if (OidIsValid(indexOid))
    {
        if (get_index_isclustered(indexOid))
            return;
    }
 
    /*
     * Check each index of the relation and set/clear the bit as needed.
     */
    pg_index = table_open(IndexRelationId, RowExclusiveLock);
 
    foreach(index, RelationGetIndexList(rel))
    {
        Oid         thisIndexOid = lfirst_oid(index);
 
        indexTuple = SearchSysCacheCopy1(INDEXRELID,
                                         ObjectIdGetDatum(thisIndexOid));
        if (!HeapTupleIsValid(indexTuple))
            elog(ERROR, "cache lookup failed for index %u", thisIndexOid);
        indexForm = (Form_pg_index) GETSTRUCT(indexTuple);
 
        /*
         * Unset the bit if set.  We know it's wrong because we checked this
         * earlier.
         */
        if (indexForm->indisclustered)
        {
            indexForm->indisclustered = false;
            CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
        }
        else if (thisIndexOid == indexOid)
        {
            /* this was checked earlier, but let's be real sure */
            if (!indexForm->indisvalid)
                elog(ERROR, "cannot cluster on invalid index %u", indexOid);
            indexForm->indisclustered = true;
            CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
        }
 
        InvokeObjectPostAlterHookArg(IndexRelationId, thisIndexOid, 0,
                                     InvalidOid, is_internal);
 
        heap_freetuple(indexTuple);
    }
 
    table_close(pg_index, RowExclusiveLock);
}

References CatalogTupleUpdate(), elog, ereport, errcode(), errmsg, ERROR, fb(), Form_pg_index, get_index_isclustered(), GETSTRUCT(), heap_freetuple(), HeapTupleIsValid, InvalidOid, InvokeObjectPostAlterHookArg, lfirst_oid, ObjectIdGetDatum(), OidIsValid, RelationData::rd_rel, RelationGetIndexList(), RowExclusiveLock, SearchSysCacheCopy1, table_close(), and table_open().

Referenced by ATExecClusterOn(), ATExecDropCluster(), and rebuild_relation().