#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

Typedefs
typedef struct ClusterParams	ClusterParams

Functions
void	cluster (ParseState pstate, ClusterStmt stmt, bool isTopLevel)

void	cluster_rel (Oid tableOid, 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_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.

◆ 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
	)

Definition at line 500 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 IndexAmRoutine::amclusterable, ereport, errcode(), errmsg(), ERROR, heap_attisnull(), index_close(), index_open(), NoLock, RelationData::rd_indam, RelationData::rd_index, RelationData::rd_indextuple, RelationGetRelationName, and RelationGetRelid.

Referenced by ATExecClusterOn(), cluster(), and cluster_rel().

◆ cluster()

void cluster	(	ParseState *	pstate,
		ClusterStmt *	stmt,
		bool	isTopLevel
	)

Definition at line 110 of file cluster.c.

 {
     ListCell   *lc;
     ClusterParams params = {0};
     bool        verbose = false;
     Relation    rel = NULL;
     Oid         indexOid = InvalidOid;
     MemoryContext cluster_context;
     List       *rtcs;
  
     /* Parse option list */
     foreach(lc, stmt->params)
     {
         DefElem    *opt = (DefElem *) lfirst(lc);
  
         if (strcmp(opt->defname, "verbose") == 0)
             verbose = defGetBoolean(opt);
         else
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("unrecognized CLUSTER option \"%s\"",
                             opt->defname),
                      parser_errposition(pstate, opt->location)));
     }
  
     params.options = (verbose ? CLUOPT_VERBOSE : 0);
  
     if (stmt->relation != NULL)
     {
         /* This is the single-relation case. */
         Oid         tableOid;
  
         /*
          * Find, lock, and check permissions on the table.  We obtain
          * AccessExclusiveLock right away to avoid lock-upgrade hazard in the
          * single-transaction case.
          */
         tableOid = RangeVarGetRelidExtended(stmt->relation,
                                             AccessExclusiveLock,
                                             0,
                                             RangeVarCallbackOwnsTable, NULL);
         rel = table_open(tableOid, NoLock);
  
         /*
          * Reject clustering a remote temp table ... their local buffer
          * manager is not going to cope.
          */
         if (RELATION_IS_OTHER_TEMP(rel))
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("cannot cluster temporary tables of other sessions")));
  
         if (stmt->indexname == NULL)
         {
             ListCell   *index;
  
             /* We need to find the index that has indisclustered set. */
             foreach(index, RelationGetIndexList(rel))
             {
                 indexOid = lfirst_oid(index);
                 if (get_index_isclustered(indexOid))
                     break;
                 indexOid = InvalidOid;
             }
  
             if (!OidIsValid(indexOid))
                 ereport(ERROR,
                         (errcode(ERRCODE_UNDEFINED_OBJECT),
                          errmsg("there is no previously clustered index for table \"%s\"",
                                 stmt->relation->relname)));
         }
         else
         {
             /*
              * The index is expected to be in the same namespace as the
              * relation.
              */
             indexOid = get_relname_relid(stmt->indexname,
                                          rel->rd_rel->relnamespace);
             if (!OidIsValid(indexOid))
                 ereport(ERROR,
                         (errcode(ERRCODE_UNDEFINED_OBJECT),
                          errmsg("index \"%s\" for table \"%s\" does not exist",
                                 stmt->indexname, stmt->relation->relname)));
         }
  
         if (rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
         {
             /* close relation, keep lock till commit */
             table_close(rel, NoLock);
  
             /* Do the job. */
             cluster_rel(tableOid, indexOid, &params);
  
             return;
         }
     }
  
     /*
      * 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, "CLUSTER");
  
     /* Also, we need a memory context to hold our list of relations */
     cluster_context = AllocSetContextCreate(PortalContext,
                                             "Cluster",
                                             ALLOCSET_DEFAULT_SIZES);
  
     /*
      * Either we're processing a partitioned table, or we were not given any
      * table name at all.  In either case, obtain a list of relations to
      * process.
      *
      * In the former case, an index name must have been given, so we don't
      * need to recheck its "indisclustered" bit, but we have to check that it
      * is an index that we can cluster on.  In the latter case, we set the
      * option bit to have indisclustered verified.
      *
      * Rechecking the relation itself is necessary here in all cases.
      */
     params.options |= CLUOPT_RECHECK;
     if (rel != NULL)
     {
         Assert(rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
         check_index_is_clusterable(rel, indexOid, AccessShareLock);
         rtcs = get_tables_to_cluster_partitioned(cluster_context, indexOid);
  
         /* close relation, releasing lock on parent table */
         table_close(rel, AccessExclusiveLock);
     }
     else
     {
         rtcs = get_tables_to_cluster(cluster_context);
         params.options |= CLUOPT_RECHECK_ISCLUSTERED;
     }
  
     /* Do the job. */
     cluster_multiple_rels(rtcs, &params);
  
     /* Start a new transaction for the cleanup work. */
     StartTransactionCommand();
  
     /* Clean up working storage */
     MemoryContextDelete(cluster_context);
 }

References AccessExclusiveLock, AccessShareLock, ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), check_index_is_clusterable(), CLUOPT_RECHECK, CLUOPT_RECHECK_ISCLUSTERED, CLUOPT_VERBOSE, cluster_multiple_rels(), cluster_rel(), defGetBoolean(), DefElem::defname, ereport, errcode(), errmsg(), ERROR, get_index_isclustered(), get_relname_relid(), get_tables_to_cluster(), get_tables_to_cluster_partitioned(), InvalidOid, lfirst, lfirst_oid, DefElem::location, MemoryContextDelete(), NoLock, OidIsValid, ClusterParams::options, parser_errposition(), PortalContext, PreventInTransactionBlock(), RangeVarCallbackOwnsTable(), RangeVarGetRelidExtended(), RelationData::rd_rel, RELATION_IS_OTHER_TEMP, RelationGetIndexList(), StartTransactionCommand(), stmt, table_close(), table_open(), and verbose.

◆ cluster_rel()

void cluster_rel	(	Oid	tableOid,
		Oid	indexOid,
		ClusterParams *	params
	)

Definition at line 312 of file cluster.c.

 {
     Relation    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);
  
     /* Check for user-requested abort. */
     CHECK_FOR_INTERRUPTS();
  
     pgstat_progress_start_command(PROGRESS_COMMAND_CLUSTER, tableOid);
     if (OidIsValid(indexOid))
         pgstat_progress_update_param(PROGRESS_CLUSTER_COMMAND,
                                      PROGRESS_CLUSTER_COMMAND_CLUSTER);
     else
         pgstat_progress_update_param(PROGRESS_CLUSTER_COMMAND,
                                      PROGRESS_CLUSTER_COMMAND_VACUUM_FULL);
  
     /*
      * We grab exclusive access to the target rel and index for the duration
      * of the transaction.  (This is redundant for the single-transaction
      * case, since cluster() already did it.)  The index lock is taken inside
      * check_index_is_clusterable.
      */
     OldHeap = try_relation_open(tableOid, AccessExclusiveLock);
  
     /* If the table has gone away, we can skip processing it */
     if (!OldHeap)
     {
         pgstat_progress_end_command();
         return;
     }
  
     /*
      * 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();
  
     /*
      * 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)
     {
         /* Check that the user still owns the relation */
         if (!object_ownercheck(RelationRelationId, tableOid, save_userid))
         {
             relation_close(OldHeap, AccessExclusiveLock);
             goto out;
         }
  
         /*
          * Silently skip a temp table for a remote session.  Only doing this
          * check in the "recheck" case is appropriate (which currently means
          * somebody is executing a database-wide CLUSTER or on a partitioned
          * table), because there is another check in cluster() which will stop
          * any attempt to cluster remote temp tables by name.  There is
          * another check in cluster_rel which is redundant, but we leave it
          * for extra safety.
          */
         if (RELATION_IS_OTHER_TEMP(OldHeap))
         {
             relation_close(OldHeap, AccessExclusiveLock);
             goto out;
         }
  
         if (OidIsValid(indexOid))
         {
             /*
              * Check that the index still exists
              */
             if (!SearchSysCacheExists1(RELOID, ObjectIdGetDatum(indexOid)))
             {
                 relation_close(OldHeap, AccessExclusiveLock);
                 goto out;
             }
  
             /*
              * Check that the index is still the one with indisclustered set,
              * if needed.
              */
             if ((params->options & CLUOPT_RECHECK_ISCLUSTERED) != 0 &&
                 !get_index_isclustered(indexOid))
             {
                 relation_close(OldHeap, AccessExclusiveLock);
                 goto out;
             }
         }
     }
  
     /*
      * We allow VACUUM FULL, but not CLUSTER, on shared catalogs.  CLUSTER
      * would work 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),
                  errmsg("cannot cluster a shared catalog")));
  
     /*
      * Don't process temp tables of other backends ... their local buffer
      * manager is not going to cope.
      */
     if (RELATION_IS_OTHER_TEMP(OldHeap))
     {
         if (OidIsValid(indexOid))
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("cannot cluster temporary tables of other sessions")));
         else
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("cannot vacuum temporary tables of other sessions")));
     }
  
     /*
      * Also check for active uses of the relation in the current transaction,
      * including open scans and pending AFTER trigger events.
      */
     CheckTableNotInUse(OldHeap, OidIsValid(indexOid) ? "CLUSTER" : "VACUUM");
  
     /* Check heap and index are valid to cluster on */
     if (OidIsValid(indexOid))
         check_index_is_clusterable(OldHeap, indexOid, AccessExclusiveLock);
  
     /*
      * 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, indexOid, verbose);
  
     /* NB: rebuild_relation does table_close() on OldHeap */
  
 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, Assert(), AtEOXact_GUC(), CHECK_FOR_INTERRUPTS, check_index_is_clusterable(), CheckTableNotInUse(), CLUOPT_RECHECK, CLUOPT_RECHECK_ISCLUSTERED, CLUOPT_VERBOSE, ereport, errcode(), errmsg(), ERROR, get_index_isclustered(), GetUserIdAndSecContext(), NewGUCNestLevel(), object_ownercheck(), ObjectIdGetDatum(), OidIsValid, ClusterParams::options, pgstat_progress_end_command(), pgstat_progress_start_command(), pgstat_progress_update_param(), PROGRESS_CLUSTER_COMMAND, PROGRESS_CLUSTER_COMMAND_CLUSTER, PROGRESS_CLUSTER_COMMAND_VACUUM_FULL, PROGRESS_COMMAND_CLUSTER, RelationData::rd_rel, rebuild_relation(), relation_close(), RELATION_IS_OTHER_TEMP, RelationIsPopulated, RELOID, SearchSysCacheExists1, SECURITY_RESTRICTED_OPERATION, SetUserIdAndSecContext(), TransferPredicateLocksToHeapRelation(), try_relation_open(), and verbose.

Referenced by cluster(), cluster_multiple_rels(), and vacuum_rel().

◆ 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
	)

Definition at line 1451 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_CLUSTER_PHASE,
                                  PROGRESS_CLUSTER_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_CLUSTER_PHASE,
                                  PROGRESS_CLUSTER_PHASE_REBUILD_INDEX);
  
     reindex_relation(OIDOldHeap, reindex_flags, &reindex_params);
  
     /* Report that we are now doing clean up */
     pgstat_progress_update_param(PROGRESS_CLUSTER_PHASE,
                                  PROGRESS_CLUSTER_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, GETSTRUCT, HeapTupleIsValid, i, NAMEDATALEN, NoLock, ObjectIdGetDatum(), OidIsValid, PERFORM_DELETION_INTERNAL, performDeletion(), pgstat_progress_update_param(), PROGRESS_CLUSTER_PHASE, PROGRESS_CLUSTER_PHASE_FINAL_CLEANUP, PROGRESS_CLUSTER_PHASE_REBUILD_INDEX, PROGRESS_CLUSTER_PHASE_SWAP_REL_FILES, RelationData::rd_rel, 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(), RELOID, RenameRelationInternal(), ResetRelRewrite(), RowExclusiveLock, SearchSysCacheCopy1, snprintf, swap_relation_files(), HeapTupleData::t_self, 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
	)

Definition at line 688 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, heap_create_with_catalog(), HeapTupleIsValid, InvalidOid, LookupCreationNamespace(), NAMEDATALEN, NewHeapCreateToastTable(), NIL, NoLock, ObjectIdGetDatum(), OidIsValid, ONCOMMIT_NOOP, RelationData::rd_rel, RelationGetDescr, RelationGetNamespace, RelationIsMapped, ReleaseSysCache(), RELOID, SearchSysCache1(), snprintf, SysCacheGetAttr(), table_close(), and table_open().

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

◆ mark_index_clustered()

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

Definition at line 560 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, get_index_isclustered(), GETSTRUCT, heap_freetuple(), HeapTupleIsValid, INDEXRELID, InvalidOid, InvokeObjectPostAlterHookArg, lfirst_oid, ObjectIdGetDatum(), OidIsValid, RelationData::rd_rel, RelationGetIndexList(), RowExclusiveLock, SearchSysCacheCopy1, HeapTupleData::t_self, table_close(), and table_open().

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

Data Structures

Macros

Typedefs

Functions