LCOV - code coverage report
Current view: top level - src/backend/commands - cluster.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 413 458 90.2 %
Date: 2024-04-13 08:11:04 Functions: 13 13 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * cluster.c
       4             :  *    CLUSTER a table on an index.  This is now also used for VACUUM FULL.
       5             :  *
       6             :  * There is hardly anything left of Paul Brown's original implementation...
       7             :  *
       8             :  *
       9             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
      10             :  * Portions Copyright (c) 1994-5, Regents of the University of California
      11             :  *
      12             :  *
      13             :  * IDENTIFICATION
      14             :  *    src/backend/commands/cluster.c
      15             :  *
      16             :  *-------------------------------------------------------------------------
      17             :  */
      18             : #include "postgres.h"
      19             : 
      20             : #include "access/amapi.h"
      21             : #include "access/heapam.h"
      22             : #include "access/multixact.h"
      23             : #include "access/relscan.h"
      24             : #include "access/tableam.h"
      25             : #include "access/toast_internals.h"
      26             : #include "access/transam.h"
      27             : #include "access/xact.h"
      28             : #include "catalog/catalog.h"
      29             : #include "catalog/dependency.h"
      30             : #include "catalog/heap.h"
      31             : #include "catalog/index.h"
      32             : #include "catalog/namespace.h"
      33             : #include "catalog/objectaccess.h"
      34             : #include "catalog/pg_am.h"
      35             : #include "catalog/pg_database.h"
      36             : #include "catalog/pg_inherits.h"
      37             : #include "catalog/toasting.h"
      38             : #include "commands/cluster.h"
      39             : #include "commands/defrem.h"
      40             : #include "commands/progress.h"
      41             : #include "commands/tablecmds.h"
      42             : #include "commands/vacuum.h"
      43             : #include "miscadmin.h"
      44             : #include "optimizer/optimizer.h"
      45             : #include "pgstat.h"
      46             : #include "storage/bufmgr.h"
      47             : #include "storage/lmgr.h"
      48             : #include "storage/predicate.h"
      49             : #include "utils/acl.h"
      50             : #include "utils/fmgroids.h"
      51             : #include "utils/guc.h"
      52             : #include "utils/inval.h"
      53             : #include "utils/lsyscache.h"
      54             : #include "utils/memutils.h"
      55             : #include "utils/pg_rusage.h"
      56             : #include "utils/relmapper.h"
      57             : #include "utils/snapmgr.h"
      58             : #include "utils/syscache.h"
      59             : 
      60             : /*
      61             :  * This struct is used to pass around the information on tables to be
      62             :  * clustered. We need this so we can make a list of them when invoked without
      63             :  * a specific table/index pair.
      64             :  */
      65             : typedef struct
      66             : {
      67             :     Oid         tableOid;
      68             :     Oid         indexOid;
      69             : } RelToCluster;
      70             : 
      71             : 
      72             : static void cluster_multiple_rels(List *rtcs, ClusterParams *params);
      73             : static void rebuild_relation(Relation OldHeap, Oid indexOid, bool verbose);
      74             : static void copy_table_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex,
      75             :                             bool verbose, bool *pSwapToastByContent,
      76             :                             TransactionId *pFreezeXid, MultiXactId *pCutoffMulti);
      77             : static List *get_tables_to_cluster(MemoryContext cluster_context);
      78             : static List *get_tables_to_cluster_partitioned(MemoryContext cluster_context,
      79             :                                                Oid indexOid);
      80             : static bool cluster_is_permitted_for_relation(Oid relid, Oid userid);
      81             : 
      82             : 
      83             : /*---------------------------------------------------------------------------
      84             :  * This cluster code allows for clustering multiple tables at once. Because
      85             :  * of this, we cannot just run everything on a single transaction, or we
      86             :  * would be forced to acquire exclusive locks on all the tables being
      87             :  * clustered, simultaneously --- very likely leading to deadlock.
      88             :  *
      89             :  * To solve this we follow a similar strategy to VACUUM code,
      90             :  * clustering each relation in a separate transaction. For this to work,
      91             :  * we need to:
      92             :  *  - provide a separate memory context so that we can pass information in
      93             :  *    a way that survives across transactions
      94             :  *  - start a new transaction every time a new relation is clustered
      95             :  *  - check for validity of the information on to-be-clustered relations,
      96             :  *    as someone might have deleted a relation behind our back, or
      97             :  *    clustered one on a different index
      98             :  *  - end the transaction
      99             :  *
     100             :  * The single-relation case does not have any such overhead.
     101             :  *
     102             :  * We also allow a relation to be specified without index.  In that case,
     103             :  * the indisclustered bit will be looked up, and an ERROR will be thrown
     104             :  * if there is no index with the bit set.
     105             :  *---------------------------------------------------------------------------
     106             :  */
     107             : void
     108         238 : cluster(ParseState *pstate, ClusterStmt *stmt, bool isTopLevel)
     109             : {
     110             :     ListCell   *lc;
     111         238 :     ClusterParams params = {0};
     112         238 :     bool        verbose = false;
     113         238 :     Relation    rel = NULL;
     114         238 :     Oid         indexOid = InvalidOid;
     115             :     MemoryContext cluster_context;
     116             :     List       *rtcs;
     117             : 
     118             :     /* Parse option list */
     119         252 :     foreach(lc, stmt->params)
     120             :     {
     121          14 :         DefElem    *opt = (DefElem *) lfirst(lc);
     122             : 
     123          14 :         if (strcmp(opt->defname, "verbose") == 0)
     124          14 :             verbose = defGetBoolean(opt);
     125             :         else
     126           0 :             ereport(ERROR,
     127             :                     (errcode(ERRCODE_SYNTAX_ERROR),
     128             :                      errmsg("unrecognized CLUSTER option \"%s\"",
     129             :                             opt->defname),
     130             :                      parser_errposition(pstate, opt->location)));
     131             :     }
     132             : 
     133         238 :     params.options = (verbose ? CLUOPT_VERBOSE : 0);
     134             : 
     135         238 :     if (stmt->relation != NULL)
     136             :     {
     137             :         /* This is the single-relation case. */
     138             :         Oid         tableOid;
     139             : 
     140             :         /*
     141             :          * Find, lock, and check permissions on the table.  We obtain
     142             :          * AccessExclusiveLock right away to avoid lock-upgrade hazard in the
     143             :          * single-transaction case.
     144             :          */
     145         208 :         tableOid = RangeVarGetRelidExtended(stmt->relation,
     146             :                                             AccessExclusiveLock,
     147             :                                             0,
     148             :                                             RangeVarCallbackMaintainsTable,
     149             :                                             NULL);
     150         196 :         rel = table_open(tableOid, NoLock);
     151             : 
     152             :         /*
     153             :          * Reject clustering a remote temp table ... their local buffer
     154             :          * manager is not going to cope.
     155             :          */
     156         196 :         if (RELATION_IS_OTHER_TEMP(rel))
     157           0 :             ereport(ERROR,
     158             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     159             :                      errmsg("cannot cluster temporary tables of other sessions")));
     160             : 
     161         196 :         if (stmt->indexname == NULL)
     162             :         {
     163             :             ListCell   *index;
     164             : 
     165             :             /* We need to find the index that has indisclustered set. */
     166          46 :             foreach(index, RelationGetIndexList(rel))
     167             :             {
     168          34 :                 indexOid = lfirst_oid(index);
     169          34 :                 if (get_index_isclustered(indexOid))
     170          22 :                     break;
     171          12 :                 indexOid = InvalidOid;
     172             :             }
     173             : 
     174          34 :             if (!OidIsValid(indexOid))
     175          12 :                 ereport(ERROR,
     176             :                         (errcode(ERRCODE_UNDEFINED_OBJECT),
     177             :                          errmsg("there is no previously clustered index for table \"%s\"",
     178             :                                 stmt->relation->relname)));
     179             :         }
     180             :         else
     181             :         {
     182             :             /*
     183             :              * The index is expected to be in the same namespace as the
     184             :              * relation.
     185             :              */
     186         162 :             indexOid = get_relname_relid(stmt->indexname,
     187         162 :                                          rel->rd_rel->relnamespace);
     188         162 :             if (!OidIsValid(indexOid))
     189           0 :                 ereport(ERROR,
     190             :                         (errcode(ERRCODE_UNDEFINED_OBJECT),
     191             :                          errmsg("index \"%s\" for table \"%s\" does not exist",
     192             :                                 stmt->indexname, stmt->relation->relname)));
     193             :         }
     194             : 
     195         184 :         if (rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
     196             :         {
     197             :             /* close relation, keep lock till commit */
     198         158 :             table_close(rel, NoLock);
     199             : 
     200             :             /* Do the job. */
     201         158 :             cluster_rel(tableOid, indexOid, &params);
     202             : 
     203         158 :             return;
     204             :         }
     205             :     }
     206             : 
     207             :     /*
     208             :      * By here, we know we are in a multi-table situation.  In order to avoid
     209             :      * holding locks for too long, we want to process each table in its own
     210             :      * transaction.  This forces us to disallow running inside a user
     211             :      * transaction block.
     212             :      */
     213          56 :     PreventInTransactionBlock(isTopLevel, "CLUSTER");
     214             : 
     215             :     /* Also, we need a memory context to hold our list of relations */
     216          56 :     cluster_context = AllocSetContextCreate(PortalContext,
     217             :                                             "Cluster",
     218             :                                             ALLOCSET_DEFAULT_SIZES);
     219             : 
     220             :     /*
     221             :      * Either we're processing a partitioned table, or we were not given any
     222             :      * table name at all.  In either case, obtain a list of relations to
     223             :      * process.
     224             :      *
     225             :      * In the former case, an index name must have been given, so we don't
     226             :      * need to recheck its "indisclustered" bit, but we have to check that it
     227             :      * is an index that we can cluster on.  In the latter case, we set the
     228             :      * option bit to have indisclustered verified.
     229             :      *
     230             :      * Rechecking the relation itself is necessary here in all cases.
     231             :      */
     232          56 :     params.options |= CLUOPT_RECHECK;
     233          56 :     if (rel != NULL)
     234             :     {
     235             :         Assert(rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
     236          26 :         check_index_is_clusterable(rel, indexOid, AccessShareLock);
     237          20 :         rtcs = get_tables_to_cluster_partitioned(cluster_context, indexOid);
     238             : 
     239             :         /* close relation, releasing lock on parent table */
     240          20 :         table_close(rel, AccessExclusiveLock);
     241             :     }
     242             :     else
     243             :     {
     244          30 :         rtcs = get_tables_to_cluster(cluster_context);
     245          30 :         params.options |= CLUOPT_RECHECK_ISCLUSTERED;
     246             :     }
     247             : 
     248             :     /* Do the job. */
     249          50 :     cluster_multiple_rels(rtcs, &params);
     250             : 
     251             :     /* Start a new transaction for the cleanup work. */
     252          50 :     StartTransactionCommand();
     253             : 
     254             :     /* Clean up working storage */
     255          50 :     MemoryContextDelete(cluster_context);
     256             : }
     257             : 
     258             : /*
     259             :  * Given a list of relations to cluster, process each of them in a separate
     260             :  * transaction.
     261             :  *
     262             :  * We expect to be in a transaction at start, but there isn't one when we
     263             :  * return.
     264             :  */
     265             : static void
     266          50 : cluster_multiple_rels(List *rtcs, ClusterParams *params)
     267             : {
     268             :     ListCell   *lc;
     269             : 
     270             :     /* Commit to get out of starting transaction */
     271          50 :     PopActiveSnapshot();
     272          50 :     CommitTransactionCommand();
     273             : 
     274             :     /* Cluster the tables, each in a separate transaction */
     275          80 :     foreach(lc, rtcs)
     276             :     {
     277          30 :         RelToCluster *rtc = (RelToCluster *) lfirst(lc);
     278             : 
     279             :         /* Start a new transaction for each relation. */
     280          30 :         StartTransactionCommand();
     281             : 
     282             :         /* functions in indexes may want a snapshot set */
     283          30 :         PushActiveSnapshot(GetTransactionSnapshot());
     284             : 
     285             :         /* Do the job. */
     286          30 :         cluster_rel(rtc->tableOid, rtc->indexOid, params);
     287             : 
     288          30 :         PopActiveSnapshot();
     289          30 :         CommitTransactionCommand();
     290             :     }
     291          50 : }
     292             : 
     293             : /*
     294             :  * cluster_rel
     295             :  *
     296             :  * This clusters the table by creating a new, clustered table and
     297             :  * swapping the relfilenumbers of the new table and the old table, so
     298             :  * the OID of the original table is preserved.  Thus we do not lose
     299             :  * GRANT, inheritance nor references to this table (this was a bug
     300             :  * in releases through 7.3).
     301             :  *
     302             :  * Indexes are rebuilt too, via REINDEX. Since we are effectively bulk-loading
     303             :  * the new table, it's better to create the indexes afterwards than to fill
     304             :  * them incrementally while we load the table.
     305             :  *
     306             :  * If indexOid is InvalidOid, the table will be rewritten in physical order
     307             :  * instead of index order.  This is the new implementation of VACUUM FULL,
     308             :  * and error messages should refer to the operation as VACUUM not CLUSTER.
     309             :  */
     310             : void
     311         526 : cluster_rel(Oid tableOid, Oid indexOid, ClusterParams *params)
     312             : {
     313             :     Relation    OldHeap;
     314             :     Oid         save_userid;
     315             :     int         save_sec_context;
     316             :     int         save_nestlevel;
     317         526 :     bool        verbose = ((params->options & CLUOPT_VERBOSE) != 0);
     318         526 :     bool        recheck = ((params->options & CLUOPT_RECHECK) != 0);
     319             : 
     320             :     /* Check for user-requested abort. */
     321         526 :     CHECK_FOR_INTERRUPTS();
     322             : 
     323         526 :     pgstat_progress_start_command(PROGRESS_COMMAND_CLUSTER, tableOid);
     324         526 :     if (OidIsValid(indexOid))
     325         188 :         pgstat_progress_update_param(PROGRESS_CLUSTER_COMMAND,
     326             :                                      PROGRESS_CLUSTER_COMMAND_CLUSTER);
     327             :     else
     328         338 :         pgstat_progress_update_param(PROGRESS_CLUSTER_COMMAND,
     329             :                                      PROGRESS_CLUSTER_COMMAND_VACUUM_FULL);
     330             : 
     331             :     /*
     332             :      * We grab exclusive access to the target rel and index for the duration
     333             :      * of the transaction.  (This is redundant for the single-transaction
     334             :      * case, since cluster() already did it.)  The index lock is taken inside
     335             :      * check_index_is_clusterable.
     336             :      */
     337         526 :     OldHeap = try_relation_open(tableOid, AccessExclusiveLock);
     338             : 
     339             :     /* If the table has gone away, we can skip processing it */
     340         526 :     if (!OldHeap)
     341             :     {
     342           0 :         pgstat_progress_end_command();
     343           0 :         return;
     344             :     }
     345             : 
     346             :     /*
     347             :      * Switch to the table owner's userid, so that any index functions are run
     348             :      * as that user.  Also lock down security-restricted operations and
     349             :      * arrange to make GUC variable changes local to this command.
     350             :      */
     351         526 :     GetUserIdAndSecContext(&save_userid, &save_sec_context);
     352         526 :     SetUserIdAndSecContext(OldHeap->rd_rel->relowner,
     353             :                            save_sec_context | SECURITY_RESTRICTED_OPERATION);
     354         526 :     save_nestlevel = NewGUCNestLevel();
     355         526 :     RestrictSearchPath();
     356             : 
     357             :     /*
     358             :      * Since we may open a new transaction for each relation, we have to check
     359             :      * that the relation still is what we think it is.
     360             :      *
     361             :      * If this is a single-transaction CLUSTER, we can skip these tests. We
     362             :      * *must* skip the one on indisclustered since it would reject an attempt
     363             :      * to cluster a not-previously-clustered index.
     364             :      */
     365         526 :     if (recheck)
     366             :     {
     367             :         /* Check that the user still has privileges for the relation */
     368          30 :         if (!cluster_is_permitted_for_relation(tableOid, save_userid))
     369             :         {
     370           0 :             relation_close(OldHeap, AccessExclusiveLock);
     371           0 :             goto out;
     372             :         }
     373             : 
     374             :         /*
     375             :          * Silently skip a temp table for a remote session.  Only doing this
     376             :          * check in the "recheck" case is appropriate (which currently means
     377             :          * somebody is executing a database-wide CLUSTER or on a partitioned
     378             :          * table), because there is another check in cluster() which will stop
     379             :          * any attempt to cluster remote temp tables by name.  There is
     380             :          * another check in cluster_rel which is redundant, but we leave it
     381             :          * for extra safety.
     382             :          */
     383          30 :         if (RELATION_IS_OTHER_TEMP(OldHeap))
     384             :         {
     385           0 :             relation_close(OldHeap, AccessExclusiveLock);
     386           0 :             goto out;
     387             :         }
     388             : 
     389          30 :         if (OidIsValid(indexOid))
     390             :         {
     391             :             /*
     392             :              * Check that the index still exists
     393             :              */
     394          30 :             if (!SearchSysCacheExists1(RELOID, ObjectIdGetDatum(indexOid)))
     395             :             {
     396           0 :                 relation_close(OldHeap, AccessExclusiveLock);
     397           0 :                 goto out;
     398             :             }
     399             : 
     400             :             /*
     401             :              * Check that the index is still the one with indisclustered set,
     402             :              * if needed.
     403             :              */
     404          30 :             if ((params->options & CLUOPT_RECHECK_ISCLUSTERED) != 0 &&
     405           6 :                 !get_index_isclustered(indexOid))
     406             :             {
     407           0 :                 relation_close(OldHeap, AccessExclusiveLock);
     408           0 :                 goto out;
     409             :             }
     410             :         }
     411             :     }
     412             : 
     413             :     /*
     414             :      * We allow VACUUM FULL, but not CLUSTER, on shared catalogs.  CLUSTER
     415             :      * would work in most respects, but the index would only get marked as
     416             :      * indisclustered in the current database, leading to unexpected behavior
     417             :      * if CLUSTER were later invoked in another database.
     418             :      */
     419         526 :     if (OidIsValid(indexOid) && OldHeap->rd_rel->relisshared)
     420           0 :         ereport(ERROR,
     421             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     422             :                  errmsg("cannot cluster a shared catalog")));
     423             : 
     424             :     /*
     425             :      * Don't process temp tables of other backends ... their local buffer
     426             :      * manager is not going to cope.
     427             :      */
     428         526 :     if (RELATION_IS_OTHER_TEMP(OldHeap))
     429             :     {
     430           0 :         if (OidIsValid(indexOid))
     431           0 :             ereport(ERROR,
     432             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     433             :                      errmsg("cannot cluster temporary tables of other sessions")));
     434             :         else
     435           0 :             ereport(ERROR,
     436             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     437             :                      errmsg("cannot vacuum temporary tables of other sessions")));
     438             :     }
     439             : 
     440             :     /*
     441             :      * Also check for active uses of the relation in the current transaction,
     442             :      * including open scans and pending AFTER trigger events.
     443             :      */
     444         526 :     CheckTableNotInUse(OldHeap, OidIsValid(indexOid) ? "CLUSTER" : "VACUUM");
     445             : 
     446             :     /* Check heap and index are valid to cluster on */
     447         526 :     if (OidIsValid(indexOid))
     448         188 :         check_index_is_clusterable(OldHeap, indexOid, AccessExclusiveLock);
     449             : 
     450             :     /*
     451             :      * Quietly ignore the request if this is a materialized view which has not
     452             :      * been populated from its query. No harm is done because there is no data
     453             :      * to deal with, and we don't want to throw an error if this is part of a
     454             :      * multi-relation request -- for example, CLUSTER was run on the entire
     455             :      * database.
     456             :      */
     457         526 :     if (OldHeap->rd_rel->relkind == RELKIND_MATVIEW &&
     458           0 :         !RelationIsPopulated(OldHeap))
     459             :     {
     460           0 :         relation_close(OldHeap, AccessExclusiveLock);
     461           0 :         goto out;
     462             :     }
     463             : 
     464             :     Assert(OldHeap->rd_rel->relkind == RELKIND_RELATION ||
     465             :            OldHeap->rd_rel->relkind == RELKIND_MATVIEW ||
     466             :            OldHeap->rd_rel->relkind == RELKIND_TOASTVALUE);
     467             : 
     468             :     /*
     469             :      * All predicate locks on the tuples or pages are about to be made
     470             :      * invalid, because we move tuples around.  Promote them to relation
     471             :      * locks.  Predicate locks on indexes will be promoted when they are
     472             :      * reindexed.
     473             :      */
     474         526 :     TransferPredicateLocksToHeapRelation(OldHeap);
     475             : 
     476             :     /* rebuild_relation does all the dirty work */
     477         526 :     rebuild_relation(OldHeap, indexOid, verbose);
     478             : 
     479             :     /* NB: rebuild_relation does table_close() on OldHeap */
     480             : 
     481         520 : out:
     482             :     /* Roll back any GUC changes executed by index functions */
     483         520 :     AtEOXact_GUC(false, save_nestlevel);
     484             : 
     485             :     /* Restore userid and security context */
     486         520 :     SetUserIdAndSecContext(save_userid, save_sec_context);
     487             : 
     488         520 :     pgstat_progress_end_command();
     489             : }
     490             : 
     491             : /*
     492             :  * Verify that the specified heap and index are valid to cluster on
     493             :  *
     494             :  * Side effect: obtains lock on the index.  The caller may
     495             :  * in some cases already have AccessExclusiveLock on the table, but
     496             :  * not in all cases so we can't rely on the table-level lock for
     497             :  * protection here.
     498             :  */
     499             : void
     500         278 : check_index_is_clusterable(Relation OldHeap, Oid indexOid, LOCKMODE lockmode)
     501             : {
     502             :     Relation    OldIndex;
     503             : 
     504         278 :     OldIndex = index_open(indexOid, lockmode);
     505             : 
     506             :     /*
     507             :      * Check that index is in fact an index on the given relation
     508             :      */
     509         278 :     if (OldIndex->rd_index == NULL ||
     510         278 :         OldIndex->rd_index->indrelid != RelationGetRelid(OldHeap))
     511           0 :         ereport(ERROR,
     512             :                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
     513             :                  errmsg("\"%s\" is not an index for table \"%s\"",
     514             :                         RelationGetRelationName(OldIndex),
     515             :                         RelationGetRelationName(OldHeap))));
     516             : 
     517             :     /* Index AM must allow clustering */
     518         278 :     if (!OldIndex->rd_indam->amclusterable)
     519           0 :         ereport(ERROR,
     520             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     521             :                  errmsg("cannot cluster on index \"%s\" because access method does not support clustering",
     522             :                         RelationGetRelationName(OldIndex))));
     523             : 
     524             :     /*
     525             :      * Disallow clustering on incomplete indexes (those that might not index
     526             :      * every row of the relation).  We could relax this by making a separate
     527             :      * seqscan pass over the table to copy the missing rows, but that seems
     528             :      * expensive and tedious.
     529             :      */
     530         278 :     if (!heap_attisnull(OldIndex->rd_indextuple, Anum_pg_index_indpred, NULL))
     531           0 :         ereport(ERROR,
     532             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     533             :                  errmsg("cannot cluster on partial index \"%s\"",
     534             :                         RelationGetRelationName(OldIndex))));
     535             : 
     536             :     /*
     537             :      * Disallow if index is left over from a failed CREATE INDEX CONCURRENTLY;
     538             :      * it might well not contain entries for every heap row, or might not even
     539             :      * be internally consistent.  (But note that we don't check indcheckxmin;
     540             :      * the worst consequence of following broken HOT chains would be that we
     541             :      * might put recently-dead tuples out-of-order in the new table, and there
     542             :      * is little harm in that.)
     543             :      */
     544         278 :     if (!OldIndex->rd_index->indisvalid)
     545           6 :         ereport(ERROR,
     546             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     547             :                  errmsg("cannot cluster on invalid index \"%s\"",
     548             :                         RelationGetRelationName(OldIndex))));
     549             : 
     550             :     /* Drop relcache refcnt on OldIndex, but keep lock */
     551         272 :     index_close(OldIndex, NoLock);
     552         272 : }
     553             : 
     554             : /*
     555             :  * mark_index_clustered: mark the specified index as the one clustered on
     556             :  *
     557             :  * With indexOid == InvalidOid, will mark all indexes of rel not-clustered.
     558             :  */
     559             : void
     560         270 : mark_index_clustered(Relation rel, Oid indexOid, bool is_internal)
     561             : {
     562             :     HeapTuple   indexTuple;
     563             :     Form_pg_index indexForm;
     564             :     Relation    pg_index;
     565             :     ListCell   *index;
     566             : 
     567             :     /* Disallow applying to a partitioned table */
     568         270 :     if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
     569          12 :         ereport(ERROR,
     570             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     571             :                  errmsg("cannot mark index clustered in partitioned table")));
     572             : 
     573             :     /*
     574             :      * If the index is already marked clustered, no need to do anything.
     575             :      */
     576         258 :     if (OidIsValid(indexOid))
     577             :     {
     578         246 :         if (get_index_isclustered(indexOid))
     579          40 :             return;
     580             :     }
     581             : 
     582             :     /*
     583             :      * Check each index of the relation and set/clear the bit as needed.
     584             :      */
     585         218 :     pg_index = table_open(IndexRelationId, RowExclusiveLock);
     586             : 
     587         642 :     foreach(index, RelationGetIndexList(rel))
     588             :     {
     589         424 :         Oid         thisIndexOid = lfirst_oid(index);
     590             : 
     591         424 :         indexTuple = SearchSysCacheCopy1(INDEXRELID,
     592             :                                          ObjectIdGetDatum(thisIndexOid));
     593         424 :         if (!HeapTupleIsValid(indexTuple))
     594           0 :             elog(ERROR, "cache lookup failed for index %u", thisIndexOid);
     595         424 :         indexForm = (Form_pg_index) GETSTRUCT(indexTuple);
     596             : 
     597             :         /*
     598             :          * Unset the bit if set.  We know it's wrong because we checked this
     599             :          * earlier.
     600             :          */
     601         424 :         if (indexForm->indisclustered)
     602             :         {
     603          30 :             indexForm->indisclustered = false;
     604          30 :             CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
     605             :         }
     606         394 :         else if (thisIndexOid == indexOid)
     607             :         {
     608             :             /* this was checked earlier, but let's be real sure */
     609         206 :             if (!indexForm->indisvalid)
     610           0 :                 elog(ERROR, "cannot cluster on invalid index %u", indexOid);
     611         206 :             indexForm->indisclustered = true;
     612         206 :             CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
     613             :         }
     614             : 
     615         424 :         InvokeObjectPostAlterHookArg(IndexRelationId, thisIndexOid, 0,
     616             :                                      InvalidOid, is_internal);
     617             : 
     618         424 :         heap_freetuple(indexTuple);
     619             :     }
     620             : 
     621         218 :     table_close(pg_index, RowExclusiveLock);
     622             : }
     623             : 
     624             : /*
     625             :  * rebuild_relation: rebuild an existing relation in index or physical order
     626             :  *
     627             :  * OldHeap: table to rebuild --- must be opened and exclusive-locked!
     628             :  * indexOid: index to cluster by, or InvalidOid to rewrite in physical order.
     629             :  *
     630             :  * NB: this routine closes OldHeap at the right time; caller should not.
     631             :  */
     632             : static void
     633         526 : rebuild_relation(Relation OldHeap, Oid indexOid, bool verbose)
     634             : {
     635         526 :     Oid         tableOid = RelationGetRelid(OldHeap);
     636         526 :     Oid         accessMethod = OldHeap->rd_rel->relam;
     637         526 :     Oid         tableSpace = OldHeap->rd_rel->reltablespace;
     638             :     Oid         OIDNewHeap;
     639             :     char        relpersistence;
     640             :     bool        is_system_catalog;
     641             :     bool        swap_toast_by_content;
     642             :     TransactionId frozenXid;
     643             :     MultiXactId cutoffMulti;
     644             : 
     645         526 :     if (OidIsValid(indexOid))
     646             :         /* Mark the correct index as clustered */
     647         188 :         mark_index_clustered(OldHeap, indexOid, true);
     648             : 
     649             :     /* Remember info about rel before closing OldHeap */
     650         526 :     relpersistence = OldHeap->rd_rel->relpersistence;
     651         526 :     is_system_catalog = IsSystemRelation(OldHeap);
     652             : 
     653             :     /* Close relcache entry, but keep lock until transaction commit */
     654         526 :     table_close(OldHeap, NoLock);
     655             : 
     656             :     /* Create the transient table that will receive the re-ordered data */
     657         526 :     OIDNewHeap = make_new_heap(tableOid, tableSpace,
     658             :                                accessMethod,
     659             :                                relpersistence,
     660             :                                AccessExclusiveLock);
     661             : 
     662             :     /* Copy the heap data into the new table in the desired order */
     663         526 :     copy_table_data(OIDNewHeap, tableOid, indexOid, verbose,
     664             :                     &swap_toast_by_content, &frozenXid, &cutoffMulti);
     665             : 
     666             :     /*
     667             :      * Swap the physical files of the target and transient tables, then
     668             :      * rebuild the target's indexes and throw away the transient table.
     669             :      */
     670         526 :     finish_heap_swap(tableOid, OIDNewHeap, is_system_catalog,
     671             :                      swap_toast_by_content, false, true,
     672             :                      frozenXid, cutoffMulti,
     673             :                      relpersistence);
     674         520 : }
     675             : 
     676             : 
     677             : /*
     678             :  * Create the transient table that will be filled with new data during
     679             :  * CLUSTER, ALTER TABLE, and similar operations.  The transient table
     680             :  * duplicates the logical structure of the OldHeap; but will have the
     681             :  * specified physical storage properties NewTableSpace, NewAccessMethod, and
     682             :  * relpersistence.
     683             :  *
     684             :  * After this, the caller should load the new heap with transferred/modified
     685             :  * data, then call finish_heap_swap to complete the operation.
     686             :  */
     687             : Oid
     688        1644 : make_new_heap(Oid OIDOldHeap, Oid NewTableSpace, Oid NewAccessMethod,
     689             :               char relpersistence, LOCKMODE lockmode)
     690             : {
     691             :     TupleDesc   OldHeapDesc;
     692             :     char        NewHeapName[NAMEDATALEN];
     693             :     Oid         OIDNewHeap;
     694             :     Oid         toastid;
     695             :     Relation    OldHeap;
     696             :     HeapTuple   tuple;
     697             :     Datum       reloptions;
     698             :     bool        isNull;
     699             :     Oid         namespaceid;
     700             : 
     701        1644 :     OldHeap = table_open(OIDOldHeap, lockmode);
     702        1644 :     OldHeapDesc = RelationGetDescr(OldHeap);
     703             : 
     704             :     /*
     705             :      * Note that the NewHeap will not receive any of the defaults or
     706             :      * constraints associated with the OldHeap; we don't need 'em, and there's
     707             :      * no reason to spend cycles inserting them into the catalogs only to
     708             :      * delete them.
     709             :      */
     710             : 
     711             :     /*
     712             :      * But we do want to use reloptions of the old heap for new heap.
     713             :      */
     714        1644 :     tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(OIDOldHeap));
     715        1644 :     if (!HeapTupleIsValid(tuple))
     716           0 :         elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
     717        1644 :     reloptions = SysCacheGetAttr(RELOID, tuple, Anum_pg_class_reloptions,
     718             :                                  &isNull);
     719        1644 :     if (isNull)
     720        1606 :         reloptions = (Datum) 0;
     721             : 
     722        1644 :     if (relpersistence == RELPERSISTENCE_TEMP)
     723         146 :         namespaceid = LookupCreationNamespace("pg_temp");
     724             :     else
     725        1498 :         namespaceid = RelationGetNamespace(OldHeap);
     726             : 
     727             :     /*
     728             :      * Create the new heap, using a temporary name in the same namespace as
     729             :      * the existing table.  NOTE: there is some risk of collision with user
     730             :      * relnames.  Working around this seems more trouble than it's worth; in
     731             :      * particular, we can't create the new heap in a different namespace from
     732             :      * the old, or we will have problems with the TEMP status of temp tables.
     733             :      *
     734             :      * Note: the new heap is not a shared relation, even if we are rebuilding
     735             :      * a shared rel.  However, we do make the new heap mapped if the source is
     736             :      * mapped.  This simplifies swap_relation_files, and is absolutely
     737             :      * necessary for rebuilding pg_class, for reasons explained there.
     738             :      */
     739        1644 :     snprintf(NewHeapName, sizeof(NewHeapName), "pg_temp_%u", OIDOldHeap);
     740             : 
     741        1644 :     OIDNewHeap = heap_create_with_catalog(NewHeapName,
     742             :                                           namespaceid,
     743             :                                           NewTableSpace,
     744             :                                           InvalidOid,
     745             :                                           InvalidOid,
     746             :                                           InvalidOid,
     747        1644 :                                           OldHeap->rd_rel->relowner,
     748             :                                           NewAccessMethod,
     749             :                                           OldHeapDesc,
     750             :                                           NIL,
     751             :                                           RELKIND_RELATION,
     752             :                                           relpersistence,
     753             :                                           false,
     754        1644 :                                           RelationIsMapped(OldHeap),
     755             :                                           ONCOMMIT_NOOP,
     756             :                                           reloptions,
     757             :                                           false,
     758             :                                           true,
     759             :                                           true,
     760             :                                           OIDOldHeap,
     761             :                                           NULL);
     762             :     Assert(OIDNewHeap != InvalidOid);
     763             : 
     764        1644 :     ReleaseSysCache(tuple);
     765             : 
     766             :     /*
     767             :      * Advance command counter so that the newly-created relation's catalog
     768             :      * tuples will be visible to table_open.
     769             :      */
     770        1644 :     CommandCounterIncrement();
     771             : 
     772             :     /*
     773             :      * If necessary, create a TOAST table for the new relation.
     774             :      *
     775             :      * If the relation doesn't have a TOAST table already, we can't need one
     776             :      * for the new relation.  The other way around is possible though: if some
     777             :      * wide columns have been dropped, NewHeapCreateToastTable can decide that
     778             :      * no TOAST table is needed for the new table.
     779             :      *
     780             :      * Note that NewHeapCreateToastTable ends with CommandCounterIncrement, so
     781             :      * that the TOAST table will be visible for insertion.
     782             :      */
     783        1644 :     toastid = OldHeap->rd_rel->reltoastrelid;
     784        1644 :     if (OidIsValid(toastid))
     785             :     {
     786             :         /* keep the existing toast table's reloptions, if any */
     787         664 :         tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(toastid));
     788         664 :         if (!HeapTupleIsValid(tuple))
     789           0 :             elog(ERROR, "cache lookup failed for relation %u", toastid);
     790         664 :         reloptions = SysCacheGetAttr(RELOID, tuple, Anum_pg_class_reloptions,
     791             :                                      &isNull);
     792         664 :         if (isNull)
     793         664 :             reloptions = (Datum) 0;
     794             : 
     795         664 :         NewHeapCreateToastTable(OIDNewHeap, reloptions, lockmode, toastid);
     796             : 
     797         664 :         ReleaseSysCache(tuple);
     798             :     }
     799             : 
     800        1644 :     table_close(OldHeap, NoLock);
     801             : 
     802        1644 :     return OIDNewHeap;
     803             : }
     804             : 
     805             : /*
     806             :  * Do the physical copying of table data.
     807             :  *
     808             :  * There are three output parameters:
     809             :  * *pSwapToastByContent is set true if toast tables must be swapped by content.
     810             :  * *pFreezeXid receives the TransactionId used as freeze cutoff point.
     811             :  * *pCutoffMulti receives the MultiXactId used as a cutoff point.
     812             :  */
     813             : static void
     814         526 : copy_table_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex, bool verbose,
     815             :                 bool *pSwapToastByContent, TransactionId *pFreezeXid,
     816             :                 MultiXactId *pCutoffMulti)
     817             : {
     818             :     Relation    NewHeap,
     819             :                 OldHeap,
     820             :                 OldIndex;
     821             :     Relation    relRelation;
     822             :     HeapTuple   reltup;
     823             :     Form_pg_class relform;
     824             :     TupleDesc   oldTupDesc PG_USED_FOR_ASSERTS_ONLY;
     825             :     TupleDesc   newTupDesc PG_USED_FOR_ASSERTS_ONLY;
     826             :     VacuumParams params;
     827             :     struct VacuumCutoffs cutoffs;
     828             :     bool        use_sort;
     829         526 :     double      num_tuples = 0,
     830         526 :                 tups_vacuumed = 0,
     831         526 :                 tups_recently_dead = 0;
     832             :     BlockNumber num_pages;
     833         526 :     int         elevel = verbose ? INFO : DEBUG2;
     834             :     PGRUsage    ru0;
     835             :     char       *nspname;
     836             : 
     837         526 :     pg_rusage_init(&ru0);
     838             : 
     839             :     /*
     840             :      * Open the relations we need.
     841             :      */
     842         526 :     NewHeap = table_open(OIDNewHeap, AccessExclusiveLock);
     843         526 :     OldHeap = table_open(OIDOldHeap, AccessExclusiveLock);
     844         526 :     if (OidIsValid(OIDOldIndex))
     845         188 :         OldIndex = index_open(OIDOldIndex, AccessExclusiveLock);
     846             :     else
     847         338 :         OldIndex = NULL;
     848             : 
     849             :     /* Store a copy of the namespace name for logging purposes */
     850         526 :     nspname = get_namespace_name(RelationGetNamespace(OldHeap));
     851             : 
     852             :     /*
     853             :      * Their tuple descriptors should be exactly alike, but here we only need
     854             :      * assume that they have the same number of columns.
     855             :      */
     856         526 :     oldTupDesc = RelationGetDescr(OldHeap);
     857         526 :     newTupDesc = RelationGetDescr(NewHeap);
     858             :     Assert(newTupDesc->natts == oldTupDesc->natts);
     859             : 
     860             :     /*
     861             :      * If the OldHeap has a toast table, get lock on the toast table to keep
     862             :      * it from being vacuumed.  This is needed because autovacuum processes
     863             :      * toast tables independently of their main tables, with no lock on the
     864             :      * latter.  If an autovacuum were to start on the toast table after we
     865             :      * compute our OldestXmin below, it would use a later OldestXmin, and then
     866             :      * possibly remove as DEAD toast tuples belonging to main tuples we think
     867             :      * are only RECENTLY_DEAD.  Then we'd fail while trying to copy those
     868             :      * tuples.
     869             :      *
     870             :      * We don't need to open the toast relation here, just lock it.  The lock
     871             :      * will be held till end of transaction.
     872             :      */
     873         526 :     if (OldHeap->rd_rel->reltoastrelid)
     874         178 :         LockRelationOid(OldHeap->rd_rel->reltoastrelid, AccessExclusiveLock);
     875             : 
     876             :     /*
     877             :      * If both tables have TOAST tables, perform toast swap by content.  It is
     878             :      * possible that the old table has a toast table but the new one doesn't,
     879             :      * if toastable columns have been dropped.  In that case we have to do
     880             :      * swap by links.  This is okay because swap by content is only essential
     881             :      * for system catalogs, and we don't support schema changes for them.
     882             :      */
     883         526 :     if (OldHeap->rd_rel->reltoastrelid && NewHeap->rd_rel->reltoastrelid)
     884             :     {
     885         178 :         *pSwapToastByContent = true;
     886             : 
     887             :         /*
     888             :          * When doing swap by content, any toast pointers written into NewHeap
     889             :          * must use the old toast table's OID, because that's where the toast
     890             :          * data will eventually be found.  Set this up by setting rd_toastoid.
     891             :          * This also tells toast_save_datum() to preserve the toast value
     892             :          * OIDs, which we want so as not to invalidate toast pointers in
     893             :          * system catalog caches, and to avoid making multiple copies of a
     894             :          * single toast value.
     895             :          *
     896             :          * Note that we must hold NewHeap open until we are done writing data,
     897             :          * since the relcache will not guarantee to remember this setting once
     898             :          * the relation is closed.  Also, this technique depends on the fact
     899             :          * that no one will try to read from the NewHeap until after we've
     900             :          * finished writing it and swapping the rels --- otherwise they could
     901             :          * follow the toast pointers to the wrong place.  (It would actually
     902             :          * work for values copied over from the old toast table, but not for
     903             :          * any values that we toast which were previously not toasted.)
     904             :          */
     905         178 :         NewHeap->rd_toastoid = OldHeap->rd_rel->reltoastrelid;
     906             :     }
     907             :     else
     908         348 :         *pSwapToastByContent = false;
     909             : 
     910             :     /*
     911             :      * Compute xids used to freeze and weed out dead tuples and multixacts.
     912             :      * Since we're going to rewrite the whole table anyway, there's no reason
     913             :      * not to be aggressive about this.
     914             :      */
     915         526 :     memset(&params, 0, sizeof(VacuumParams));
     916         526 :     vacuum_get_cutoffs(OldHeap, &params, &cutoffs);
     917             : 
     918             :     /*
     919             :      * FreezeXid will become the table's new relfrozenxid, and that mustn't go
     920             :      * backwards, so take the max.
     921             :      */
     922        1052 :     if (TransactionIdIsValid(OldHeap->rd_rel->relfrozenxid) &&
     923         526 :         TransactionIdPrecedes(cutoffs.FreezeLimit,
     924         526 :                               OldHeap->rd_rel->relfrozenxid))
     925          96 :         cutoffs.FreezeLimit = OldHeap->rd_rel->relfrozenxid;
     926             : 
     927             :     /*
     928             :      * MultiXactCutoff, similarly, shouldn't go backwards either.
     929             :      */
     930        1052 :     if (MultiXactIdIsValid(OldHeap->rd_rel->relminmxid) &&
     931         526 :         MultiXactIdPrecedes(cutoffs.MultiXactCutoff,
     932         526 :                             OldHeap->rd_rel->relminmxid))
     933           0 :         cutoffs.MultiXactCutoff = OldHeap->rd_rel->relminmxid;
     934             : 
     935             :     /*
     936             :      * Decide whether to use an indexscan or seqscan-and-optional-sort to scan
     937             :      * the OldHeap.  We know how to use a sort to duplicate the ordering of a
     938             :      * btree index, and will use seqscan-and-sort for that case if the planner
     939             :      * tells us it's cheaper.  Otherwise, always indexscan if an index is
     940             :      * provided, else plain seqscan.
     941             :      */
     942         526 :     if (OldIndex != NULL && OldIndex->rd_rel->relam == BTREE_AM_OID)
     943         188 :         use_sort = plan_cluster_use_sort(OIDOldHeap, OIDOldIndex);
     944             :     else
     945         338 :         use_sort = false;
     946             : 
     947             :     /* Log what we're doing */
     948         526 :     if (OldIndex != NULL && !use_sort)
     949          78 :         ereport(elevel,
     950             :                 (errmsg("clustering \"%s.%s\" using index scan on \"%s\"",
     951             :                         nspname,
     952             :                         RelationGetRelationName(OldHeap),
     953             :                         RelationGetRelationName(OldIndex))));
     954         448 :     else if (use_sort)
     955         110 :         ereport(elevel,
     956             :                 (errmsg("clustering \"%s.%s\" using sequential scan and sort",
     957             :                         nspname,
     958             :                         RelationGetRelationName(OldHeap))));
     959             :     else
     960         338 :         ereport(elevel,
     961             :                 (errmsg("vacuuming \"%s.%s\"",
     962             :                         nspname,
     963             :                         RelationGetRelationName(OldHeap))));
     964             : 
     965             :     /*
     966             :      * Hand off the actual copying to AM specific function, the generic code
     967             :      * cannot know how to deal with visibility across AMs. Note that this
     968             :      * routine is allowed to set FreezeXid / MultiXactCutoff to different
     969             :      * values (e.g. because the AM doesn't use freezing).
     970             :      */
     971         526 :     table_relation_copy_for_cluster(OldHeap, NewHeap, OldIndex, use_sort,
     972             :                                     cutoffs.OldestXmin, &cutoffs.FreezeLimit,
     973             :                                     &cutoffs.MultiXactCutoff,
     974             :                                     &num_tuples, &tups_vacuumed,
     975             :                                     &tups_recently_dead);
     976             : 
     977             :     /* return selected values to caller, get set as relfrozenxid/minmxid */
     978         526 :     *pFreezeXid = cutoffs.FreezeLimit;
     979         526 :     *pCutoffMulti = cutoffs.MultiXactCutoff;
     980             : 
     981             :     /* Reset rd_toastoid just to be tidy --- it shouldn't be looked at again */
     982         526 :     NewHeap->rd_toastoid = InvalidOid;
     983             : 
     984         526 :     num_pages = RelationGetNumberOfBlocks(NewHeap);
     985             : 
     986             :     /* Log what we did */
     987         526 :     ereport(elevel,
     988             :             (errmsg("\"%s.%s\": found %.0f removable, %.0f nonremovable row versions in %u pages",
     989             :                     nspname,
     990             :                     RelationGetRelationName(OldHeap),
     991             :                     tups_vacuumed, num_tuples,
     992             :                     RelationGetNumberOfBlocks(OldHeap)),
     993             :              errdetail("%.0f dead row versions cannot be removed yet.\n"
     994             :                        "%s.",
     995             :                        tups_recently_dead,
     996             :                        pg_rusage_show(&ru0))));
     997             : 
     998         526 :     if (OldIndex != NULL)
     999         188 :         index_close(OldIndex, NoLock);
    1000         526 :     table_close(OldHeap, NoLock);
    1001         526 :     table_close(NewHeap, NoLock);
    1002             : 
    1003             :     /* Update pg_class to reflect the correct values of pages and tuples. */
    1004         526 :     relRelation = table_open(RelationRelationId, RowExclusiveLock);
    1005             : 
    1006         526 :     reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDNewHeap));
    1007         526 :     if (!HeapTupleIsValid(reltup))
    1008           0 :         elog(ERROR, "cache lookup failed for relation %u", OIDNewHeap);
    1009         526 :     relform = (Form_pg_class) GETSTRUCT(reltup);
    1010             : 
    1011         526 :     relform->relpages = num_pages;
    1012         526 :     relform->reltuples = num_tuples;
    1013             : 
    1014             :     /* Don't update the stats for pg_class.  See swap_relation_files. */
    1015         526 :     if (OIDOldHeap != RelationRelationId)
    1016         502 :         CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
    1017             :     else
    1018          24 :         CacheInvalidateRelcacheByTuple(reltup);
    1019             : 
    1020             :     /* Clean up. */
    1021         526 :     heap_freetuple(reltup);
    1022         526 :     table_close(relRelation, RowExclusiveLock);
    1023             : 
    1024             :     /* Make the update visible */
    1025         526 :     CommandCounterIncrement();
    1026         526 : }
    1027             : 
    1028             : /*
    1029             :  * Swap the physical files of two given relations.
    1030             :  *
    1031             :  * We swap the physical identity (reltablespace, relfilenumber) while keeping
    1032             :  * the same logical identities of the two relations.  relpersistence is also
    1033             :  * swapped, which is critical since it determines where buffers live for each
    1034             :  * relation.
    1035             :  *
    1036             :  * We can swap associated TOAST data in either of two ways: recursively swap
    1037             :  * the physical content of the toast tables (and their indexes), or swap the
    1038             :  * TOAST links in the given relations' pg_class entries.  The former is needed
    1039             :  * to manage rewrites of shared catalogs (where we cannot change the pg_class
    1040             :  * links) while the latter is the only way to handle cases in which a toast
    1041             :  * table is added or removed altogether.
    1042             :  *
    1043             :  * Additionally, the first relation is marked with relfrozenxid set to
    1044             :  * frozenXid.  It seems a bit ugly to have this here, but the caller would
    1045             :  * have to do it anyway, so having it here saves a heap_update.  Note: in
    1046             :  * the swap-toast-links case, we assume we don't need to change the toast
    1047             :  * table's relfrozenxid: the new version of the toast table should already
    1048             :  * have relfrozenxid set to RecentXmin, which is good enough.
    1049             :  *
    1050             :  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
    1051             :  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
    1052             :  * having to look the information up again later in finish_heap_swap.
    1053             :  */
    1054             : static void
    1055        1868 : swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
    1056             :                     bool swap_toast_by_content,
    1057             :                     bool is_internal,
    1058             :                     TransactionId frozenXid,
    1059             :                     MultiXactId cutoffMulti,
    1060             :                     Oid *mapped_tables)
    1061             : {
    1062             :     Relation    relRelation;
    1063             :     HeapTuple   reltup1,
    1064             :                 reltup2;
    1065             :     Form_pg_class relform1,
    1066             :                 relform2;
    1067             :     RelFileNumber relfilenumber1,
    1068             :                 relfilenumber2;
    1069             :     RelFileNumber swaptemp;
    1070             :     char        swptmpchr;
    1071             :     Oid         relam1,
    1072             :                 relam2;
    1073             : 
    1074             :     /* We need writable copies of both pg_class tuples. */
    1075        1868 :     relRelation = table_open(RelationRelationId, RowExclusiveLock);
    1076             : 
    1077        1868 :     reltup1 = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(r1));
    1078        1868 :     if (!HeapTupleIsValid(reltup1))
    1079           0 :         elog(ERROR, "cache lookup failed for relation %u", r1);
    1080        1868 :     relform1 = (Form_pg_class) GETSTRUCT(reltup1);
    1081             : 
    1082        1868 :     reltup2 = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(r2));
    1083        1868 :     if (!HeapTupleIsValid(reltup2))
    1084           0 :         elog(ERROR, "cache lookup failed for relation %u", r2);
    1085        1868 :     relform2 = (Form_pg_class) GETSTRUCT(reltup2);
    1086             : 
    1087        1868 :     relfilenumber1 = relform1->relfilenode;
    1088        1868 :     relfilenumber2 = relform2->relfilenode;
    1089        1868 :     relam1 = relform1->relam;
    1090        1868 :     relam2 = relform2->relam;
    1091             : 
    1092        1868 :     if (RelFileNumberIsValid(relfilenumber1) &&
    1093             :         RelFileNumberIsValid(relfilenumber2))
    1094             :     {
    1095             :         /*
    1096             :          * Normal non-mapped relations: swap relfilenumbers, reltablespaces,
    1097             :          * relpersistence
    1098             :          */
    1099             :         Assert(!target_is_pg_class);
    1100             : 
    1101        1706 :         swaptemp = relform1->relfilenode;
    1102        1706 :         relform1->relfilenode = relform2->relfilenode;
    1103        1706 :         relform2->relfilenode = swaptemp;
    1104             : 
    1105        1706 :         swaptemp = relform1->reltablespace;
    1106        1706 :         relform1->reltablespace = relform2->reltablespace;
    1107        1706 :         relform2->reltablespace = swaptemp;
    1108             : 
    1109        1706 :         swaptemp = relform1->relam;
    1110        1706 :         relform1->relam = relform2->relam;
    1111        1706 :         relform2->relam = swaptemp;
    1112             : 
    1113        1706 :         swptmpchr = relform1->relpersistence;
    1114        1706 :         relform1->relpersistence = relform2->relpersistence;
    1115        1706 :         relform2->relpersistence = swptmpchr;
    1116             : 
    1117             :         /* Also swap toast links, if we're swapping by links */
    1118        1706 :         if (!swap_toast_by_content)
    1119             :         {
    1120        1304 :             swaptemp = relform1->reltoastrelid;
    1121        1304 :             relform1->reltoastrelid = relform2->reltoastrelid;
    1122        1304 :             relform2->reltoastrelid = swaptemp;
    1123             :         }
    1124             :     }
    1125             :     else
    1126             :     {
    1127             :         /*
    1128             :          * Mapped-relation case.  Here we have to swap the relation mappings
    1129             :          * instead of modifying the pg_class columns.  Both must be mapped.
    1130             :          */
    1131         162 :         if (RelFileNumberIsValid(relfilenumber1) ||
    1132             :             RelFileNumberIsValid(relfilenumber2))
    1133           0 :             elog(ERROR, "cannot swap mapped relation \"%s\" with non-mapped relation",
    1134             :                  NameStr(relform1->relname));
    1135             : 
    1136             :         /*
    1137             :          * We can't change the tablespace nor persistence of a mapped rel, and
    1138             :          * we can't handle toast link swapping for one either, because we must
    1139             :          * not apply any critical changes to its pg_class row.  These cases
    1140             :          * should be prevented by upstream permissions tests, so these checks
    1141             :          * are non-user-facing emergency backstop.
    1142             :          */
    1143         162 :         if (relform1->reltablespace != relform2->reltablespace)
    1144           0 :             elog(ERROR, "cannot change tablespace of mapped relation \"%s\"",
    1145             :                  NameStr(relform1->relname));
    1146         162 :         if (relform1->relpersistence != relform2->relpersistence)
    1147           0 :             elog(ERROR, "cannot change persistence of mapped relation \"%s\"",
    1148             :                  NameStr(relform1->relname));
    1149         162 :         if (relform1->relam != relform2->relam)
    1150           0 :             elog(ERROR, "cannot change access method of mapped relation \"%s\"",
    1151             :                  NameStr(relform1->relname));
    1152         162 :         if (!swap_toast_by_content &&
    1153          30 :             (relform1->reltoastrelid || relform2->reltoastrelid))
    1154           0 :             elog(ERROR, "cannot swap toast by links for mapped relation \"%s\"",
    1155             :                  NameStr(relform1->relname));
    1156             : 
    1157             :         /*
    1158             :          * Fetch the mappings --- shouldn't fail, but be paranoid
    1159             :          */
    1160         162 :         relfilenumber1 = RelationMapOidToFilenumber(r1, relform1->relisshared);
    1161         162 :         if (!RelFileNumberIsValid(relfilenumber1))
    1162           0 :             elog(ERROR, "could not find relation mapping for relation \"%s\", OID %u",
    1163             :                  NameStr(relform1->relname), r1);
    1164         162 :         relfilenumber2 = RelationMapOidToFilenumber(r2, relform2->relisshared);
    1165         162 :         if (!RelFileNumberIsValid(relfilenumber2))
    1166           0 :             elog(ERROR, "could not find relation mapping for relation \"%s\", OID %u",
    1167             :                  NameStr(relform2->relname), r2);
    1168             : 
    1169             :         /*
    1170             :          * Send replacement mappings to relmapper.  Note these won't actually
    1171             :          * take effect until CommandCounterIncrement.
    1172             :          */
    1173         162 :         RelationMapUpdateMap(r1, relfilenumber2, relform1->relisshared, false);
    1174         162 :         RelationMapUpdateMap(r2, relfilenumber1, relform2->relisshared, false);
    1175             : 
    1176             :         /* Pass OIDs of mapped r2 tables back to caller */
    1177         162 :         *mapped_tables++ = r2;
    1178             :     }
    1179             : 
    1180             :     /*
    1181             :      * Recognize that rel1's relfilenumber (swapped from rel2) is new in this
    1182             :      * subtransaction. The rel2 storage (swapped from rel1) may or may not be
    1183             :      * new.
    1184             :      */
    1185             :     {
    1186             :         Relation    rel1,
    1187             :                     rel2;
    1188             : 
    1189        1868 :         rel1 = relation_open(r1, NoLock);
    1190        1868 :         rel2 = relation_open(r2, NoLock);
    1191        1868 :         rel2->rd_createSubid = rel1->rd_createSubid;
    1192        1868 :         rel2->rd_newRelfilelocatorSubid = rel1->rd_newRelfilelocatorSubid;
    1193        1868 :         rel2->rd_firstRelfilelocatorSubid = rel1->rd_firstRelfilelocatorSubid;
    1194        1868 :         RelationAssumeNewRelfilelocator(rel1);
    1195        1868 :         relation_close(rel1, NoLock);
    1196        1868 :         relation_close(rel2, NoLock);
    1197             :     }
    1198             : 
    1199             :     /*
    1200             :      * In the case of a shared catalog, these next few steps will only affect
    1201             :      * our own database's pg_class row; but that's okay, because they are all
    1202             :      * noncritical updates.  That's also an important fact for the case of a
    1203             :      * mapped catalog, because it's possible that we'll commit the map change
    1204             :      * and then fail to commit the pg_class update.
    1205             :      */
    1206             : 
    1207             :     /* set rel1's frozen Xid and minimum MultiXid */
    1208        1868 :     if (relform1->relkind != RELKIND_INDEX)
    1209             :     {
    1210             :         Assert(!TransactionIdIsValid(frozenXid) ||
    1211             :                TransactionIdIsNormal(frozenXid));
    1212        1690 :         relform1->relfrozenxid = frozenXid;
    1213        1690 :         relform1->relminmxid = cutoffMulti;
    1214             :     }
    1215             : 
    1216             :     /* swap size statistics too, since new rel has freshly-updated stats */
    1217             :     {
    1218             :         int32       swap_pages;
    1219             :         float4      swap_tuples;
    1220             :         int32       swap_allvisible;
    1221             : 
    1222        1868 :         swap_pages = relform1->relpages;
    1223        1868 :         relform1->relpages = relform2->relpages;
    1224        1868 :         relform2->relpages = swap_pages;
    1225             : 
    1226        1868 :         swap_tuples = relform1->reltuples;
    1227        1868 :         relform1->reltuples = relform2->reltuples;
    1228        1868 :         relform2->reltuples = swap_tuples;
    1229             : 
    1230        1868 :         swap_allvisible = relform1->relallvisible;
    1231        1868 :         relform1->relallvisible = relform2->relallvisible;
    1232        1868 :         relform2->relallvisible = swap_allvisible;
    1233             :     }
    1234             : 
    1235             :     /*
    1236             :      * Update the tuples in pg_class --- unless the target relation of the
    1237             :      * swap is pg_class itself.  In that case, there is zero point in making
    1238             :      * changes because we'd be updating the old data that we're about to throw
    1239             :      * away.  Because the real work being done here for a mapped relation is
    1240             :      * just to change the relation map settings, it's all right to not update
    1241             :      * the pg_class rows in this case. The most important changes will instead
    1242             :      * performed later, in finish_heap_swap() itself.
    1243             :      */
    1244        1868 :     if (!target_is_pg_class)
    1245             :     {
    1246             :         CatalogIndexState indstate;
    1247             : 
    1248        1844 :         indstate = CatalogOpenIndexes(relRelation);
    1249        1844 :         CatalogTupleUpdateWithInfo(relRelation, &reltup1->t_self, reltup1,
    1250             :                                    indstate);
    1251        1844 :         CatalogTupleUpdateWithInfo(relRelation, &reltup2->t_self, reltup2,
    1252             :                                    indstate);
    1253        1844 :         CatalogCloseIndexes(indstate);
    1254             :     }
    1255             :     else
    1256             :     {
    1257             :         /* no update ... but we do still need relcache inval */
    1258          24 :         CacheInvalidateRelcacheByTuple(reltup1);
    1259          24 :         CacheInvalidateRelcacheByTuple(reltup2);
    1260             :     }
    1261             : 
    1262             :     /*
    1263             :      * Now that pg_class has been updated with its relevant information for
    1264             :      * the swap, update the dependency of the relations to point to their new
    1265             :      * table AM, if it has changed.
    1266             :      */
    1267        1868 :     if (relam1 != relam2)
    1268             :     {
    1269          36 :         if (changeDependencyFor(RelationRelationId,
    1270             :                                 r1,
    1271             :                                 AccessMethodRelationId,
    1272             :                                 relam1,
    1273             :                                 relam2) != 1)
    1274           0 :             elog(ERROR, "could not change access method dependency for relation \"%s.%s\"",
    1275             :                  get_namespace_name(get_rel_namespace(r1)),
    1276             :                  get_rel_name(r1));
    1277          36 :         if (changeDependencyFor(RelationRelationId,
    1278             :                                 r2,
    1279             :                                 AccessMethodRelationId,
    1280             :                                 relam2,
    1281             :                                 relam1) != 1)
    1282           0 :             elog(ERROR, "could not change access method dependency for relation \"%s.%s\"",
    1283             :                  get_namespace_name(get_rel_namespace(r2)),
    1284             :                  get_rel_name(r2));
    1285             :     }
    1286             : 
    1287             :     /*
    1288             :      * Post alter hook for modified relations. The change to r2 is always
    1289             :      * internal, but r1 depends on the invocation context.
    1290             :      */
    1291        1868 :     InvokeObjectPostAlterHookArg(RelationRelationId, r1, 0,
    1292             :                                  InvalidOid, is_internal);
    1293        1868 :     InvokeObjectPostAlterHookArg(RelationRelationId, r2, 0,
    1294             :                                  InvalidOid, true);
    1295             : 
    1296             :     /*
    1297             :      * If we have toast tables associated with the relations being swapped,
    1298             :      * deal with them too.
    1299             :      */
    1300        1868 :     if (relform1->reltoastrelid || relform2->reltoastrelid)
    1301             :     {
    1302         622 :         if (swap_toast_by_content)
    1303             :         {
    1304         178 :             if (relform1->reltoastrelid && relform2->reltoastrelid)
    1305             :             {
    1306             :                 /* Recursively swap the contents of the toast tables */
    1307         178 :                 swap_relation_files(relform1->reltoastrelid,
    1308             :                                     relform2->reltoastrelid,
    1309             :                                     target_is_pg_class,
    1310             :                                     swap_toast_by_content,
    1311             :                                     is_internal,
    1312             :                                     frozenXid,
    1313             :                                     cutoffMulti,
    1314             :                                     mapped_tables);
    1315             :             }
    1316             :             else
    1317             :             {
    1318             :                 /* caller messed up */
    1319           0 :                 elog(ERROR, "cannot swap toast files by content when there's only one");
    1320             :             }
    1321             :         }
    1322             :         else
    1323             :         {
    1324             :             /*
    1325             :              * We swapped the ownership links, so we need to change dependency
    1326             :              * data to match.
    1327             :              *
    1328             :              * NOTE: it is possible that only one table has a toast table.
    1329             :              *
    1330             :              * NOTE: at present, a TOAST table's only dependency is the one on
    1331             :              * its owning table.  If more are ever created, we'd need to use
    1332             :              * something more selective than deleteDependencyRecordsFor() to
    1333             :              * get rid of just the link we want.
    1334             :              */
    1335             :             ObjectAddress baseobject,
    1336             :                         toastobject;
    1337             :             long        count;
    1338             : 
    1339             :             /*
    1340             :              * We disallow this case for system catalogs, to avoid the
    1341             :              * possibility that the catalog we're rebuilding is one of the
    1342             :              * ones the dependency changes would change.  It's too late to be
    1343             :              * making any data changes to the target catalog.
    1344             :              */
    1345         444 :             if (IsSystemClass(r1, relform1))
    1346           0 :                 elog(ERROR, "cannot swap toast files by links for system catalogs");
    1347             : 
    1348             :             /* Delete old dependencies */
    1349         444 :             if (relform1->reltoastrelid)
    1350             :             {
    1351         412 :                 count = deleteDependencyRecordsFor(RelationRelationId,
    1352             :                                                    relform1->reltoastrelid,
    1353             :                                                    false);
    1354         412 :                 if (count != 1)
    1355           0 :                     elog(ERROR, "expected one dependency record for TOAST table, found %ld",
    1356             :                          count);
    1357             :             }
    1358         444 :             if (relform2->reltoastrelid)
    1359             :             {
    1360         444 :                 count = deleteDependencyRecordsFor(RelationRelationId,
    1361             :                                                    relform2->reltoastrelid,
    1362             :                                                    false);
    1363         444 :                 if (count != 1)
    1364           0 :                     elog(ERROR, "expected one dependency record for TOAST table, found %ld",
    1365             :                          count);
    1366             :             }
    1367             : 
    1368             :             /* Register new dependencies */
    1369         444 :             baseobject.classId = RelationRelationId;
    1370         444 :             baseobject.objectSubId = 0;
    1371         444 :             toastobject.classId = RelationRelationId;
    1372         444 :             toastobject.objectSubId = 0;
    1373             : 
    1374         444 :             if (relform1->reltoastrelid)
    1375             :             {
    1376         412 :                 baseobject.objectId = r1;
    1377         412 :                 toastobject.objectId = relform1->reltoastrelid;
    1378         412 :                 recordDependencyOn(&toastobject, &baseobject,
    1379             :                                    DEPENDENCY_INTERNAL);
    1380             :             }
    1381             : 
    1382         444 :             if (relform2->reltoastrelid)
    1383             :             {
    1384         444 :                 baseobject.objectId = r2;
    1385         444 :                 toastobject.objectId = relform2->reltoastrelid;
    1386         444 :                 recordDependencyOn(&toastobject, &baseobject,
    1387             :                                    DEPENDENCY_INTERNAL);
    1388             :             }
    1389             :         }
    1390             :     }
    1391             : 
    1392             :     /*
    1393             :      * If we're swapping two toast tables by content, do the same for their
    1394             :      * valid index. The swap can actually be safely done only if the relations
    1395             :      * have indexes.
    1396             :      */
    1397        1868 :     if (swap_toast_by_content &&
    1398         534 :         relform1->relkind == RELKIND_TOASTVALUE &&
    1399         178 :         relform2->relkind == RELKIND_TOASTVALUE)
    1400             :     {
    1401             :         Oid         toastIndex1,
    1402             :                     toastIndex2;
    1403             : 
    1404             :         /* Get valid index for each relation */
    1405         178 :         toastIndex1 = toast_get_valid_index(r1,
    1406             :                                             AccessExclusiveLock);
    1407         178 :         toastIndex2 = toast_get_valid_index(r2,
    1408             :                                             AccessExclusiveLock);
    1409             : 
    1410         178 :         swap_relation_files(toastIndex1,
    1411             :                             toastIndex2,
    1412             :                             target_is_pg_class,
    1413             :                             swap_toast_by_content,
    1414             :                             is_internal,
    1415             :                             InvalidTransactionId,
    1416             :                             InvalidMultiXactId,
    1417             :                             mapped_tables);
    1418             :     }
    1419             : 
    1420             :     /* Clean up. */
    1421        1868 :     heap_freetuple(reltup1);
    1422        1868 :     heap_freetuple(reltup2);
    1423             : 
    1424        1868 :     table_close(relRelation, RowExclusiveLock);
    1425        1868 : }
    1426             : 
    1427             : /*
    1428             :  * Remove the transient table that was built by make_new_heap, and finish
    1429             :  * cleaning up (including rebuilding all indexes on the old heap).
    1430             :  */
    1431             : void
    1432        1512 : finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
    1433             :                  bool is_system_catalog,
    1434             :                  bool swap_toast_by_content,
    1435             :                  bool check_constraints,
    1436             :                  bool is_internal,
    1437             :                  TransactionId frozenXid,
    1438             :                  MultiXactId cutoffMulti,
    1439             :                  char newrelpersistence)
    1440             : {
    1441             :     ObjectAddress object;
    1442             :     Oid         mapped_tables[4];
    1443             :     int         reindex_flags;
    1444        1512 :     ReindexParams reindex_params = {0};
    1445             :     int         i;
    1446             : 
    1447             :     /* Report that we are now swapping relation files */
    1448        1512 :     pgstat_progress_update_param(PROGRESS_CLUSTER_PHASE,
    1449             :                                  PROGRESS_CLUSTER_PHASE_SWAP_REL_FILES);
    1450             : 
    1451             :     /* Zero out possible results from swapped_relation_files */
    1452        1512 :     memset(mapped_tables, 0, sizeof(mapped_tables));
    1453             : 
    1454             :     /*
    1455             :      * Swap the contents of the heap relations (including any toast tables).
    1456             :      * Also set old heap's relfrozenxid to frozenXid.
    1457             :      */
    1458        1512 :     swap_relation_files(OIDOldHeap, OIDNewHeap,
    1459             :                         (OIDOldHeap == RelationRelationId),
    1460             :                         swap_toast_by_content, is_internal,
    1461             :                         frozenXid, cutoffMulti, mapped_tables);
    1462             : 
    1463             :     /*
    1464             :      * If it's a system catalog, queue a sinval message to flush all catcaches
    1465             :      * on the catalog when we reach CommandCounterIncrement.
    1466             :      */
    1467        1512 :     if (is_system_catalog)
    1468         202 :         CacheInvalidateCatalog(OIDOldHeap);
    1469             : 
    1470             :     /*
    1471             :      * Rebuild each index on the relation (but not the toast table, which is
    1472             :      * all-new at this point).  It is important to do this before the DROP
    1473             :      * step because if we are processing a system catalog that will be used
    1474             :      * during DROP, we want to have its indexes available.  There is no
    1475             :      * advantage to the other order anyway because this is all transactional,
    1476             :      * so no chance to reclaim disk space before commit.  We do not need a
    1477             :      * final CommandCounterIncrement() because reindex_relation does it.
    1478             :      *
    1479             :      * Note: because index_build is called via reindex_relation, it will never
    1480             :      * set indcheckxmin true for the indexes.  This is OK even though in some
    1481             :      * sense we are building new indexes rather than rebuilding existing ones,
    1482             :      * because the new heap won't contain any HOT chains at all, let alone
    1483             :      * broken ones, so it can't be necessary to set indcheckxmin.
    1484             :      */
    1485        1512 :     reindex_flags = REINDEX_REL_SUPPRESS_INDEX_USE;
    1486        1512 :     if (check_constraints)
    1487         986 :         reindex_flags |= REINDEX_REL_CHECK_CONSTRAINTS;
    1488             : 
    1489             :     /*
    1490             :      * Ensure that the indexes have the same persistence as the parent
    1491             :      * relation.
    1492             :      */
    1493        1512 :     if (newrelpersistence == RELPERSISTENCE_UNLOGGED)
    1494          38 :         reindex_flags |= REINDEX_REL_FORCE_INDEXES_UNLOGGED;
    1495        1474 :     else if (newrelpersistence == RELPERSISTENCE_PERMANENT)
    1496        1400 :         reindex_flags |= REINDEX_REL_FORCE_INDEXES_PERMANENT;
    1497             : 
    1498             :     /* Report that we are now reindexing relations */
    1499        1512 :     pgstat_progress_update_param(PROGRESS_CLUSTER_PHASE,
    1500             :                                  PROGRESS_CLUSTER_PHASE_REBUILD_INDEX);
    1501             : 
    1502        1512 :     reindex_relation(NULL, OIDOldHeap, reindex_flags, &reindex_params);
    1503             : 
    1504             :     /* Report that we are now doing clean up */
    1505        1494 :     pgstat_progress_update_param(PROGRESS_CLUSTER_PHASE,
    1506             :                                  PROGRESS_CLUSTER_PHASE_FINAL_CLEANUP);
    1507             : 
    1508             :     /*
    1509             :      * If the relation being rebuilt is pg_class, swap_relation_files()
    1510             :      * couldn't update pg_class's own pg_class entry (check comments in
    1511             :      * swap_relation_files()), thus relfrozenxid was not updated. That's
    1512             :      * annoying because a potential reason for doing a VACUUM FULL is a
    1513             :      * imminent or actual anti-wraparound shutdown.  So, now that we can
    1514             :      * access the new relation using its indices, update relfrozenxid.
    1515             :      * pg_class doesn't have a toast relation, so we don't need to update the
    1516             :      * corresponding toast relation. Not that there's little point moving all
    1517             :      * relfrozenxid updates here since swap_relation_files() needs to write to
    1518             :      * pg_class for non-mapped relations anyway.
    1519             :      */
    1520        1494 :     if (OIDOldHeap == RelationRelationId)
    1521             :     {
    1522             :         Relation    relRelation;
    1523             :         HeapTuple   reltup;
    1524             :         Form_pg_class relform;
    1525             : 
    1526          24 :         relRelation = table_open(RelationRelationId, RowExclusiveLock);
    1527             : 
    1528          24 :         reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
    1529          24 :         if (!HeapTupleIsValid(reltup))
    1530           0 :             elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
    1531          24 :         relform = (Form_pg_class) GETSTRUCT(reltup);
    1532             : 
    1533          24 :         relform->relfrozenxid = frozenXid;
    1534          24 :         relform->relminmxid = cutoffMulti;
    1535             : 
    1536          24 :         CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
    1537             : 
    1538          24 :         table_close(relRelation, RowExclusiveLock);
    1539             :     }
    1540             : 
    1541             :     /* Destroy new heap with old filenumber */
    1542        1494 :     object.classId = RelationRelationId;
    1543        1494 :     object.objectId = OIDNewHeap;
    1544        1494 :     object.objectSubId = 0;
    1545             : 
    1546             :     /*
    1547             :      * The new relation is local to our transaction and we know nothing
    1548             :      * depends on it, so DROP_RESTRICT should be OK.
    1549             :      */
    1550        1494 :     performDeletion(&object, DROP_RESTRICT, PERFORM_DELETION_INTERNAL);
    1551             : 
    1552             :     /* performDeletion does CommandCounterIncrement at end */
    1553             : 
    1554             :     /*
    1555             :      * Now we must remove any relation mapping entries that we set up for the
    1556             :      * transient table, as well as its toast table and toast index if any. If
    1557             :      * we fail to do this before commit, the relmapper will complain about new
    1558             :      * permanent map entries being added post-bootstrap.
    1559             :      */
    1560        1656 :     for (i = 0; OidIsValid(mapped_tables[i]); i++)
    1561         162 :         RelationMapRemoveMapping(mapped_tables[i]);
    1562             : 
    1563             :     /*
    1564             :      * At this point, everything is kosher except that, if we did toast swap
    1565             :      * by links, the toast table's name corresponds to the transient table.
    1566             :      * The name is irrelevant to the backend because it's referenced by OID,
    1567             :      * but users looking at the catalogs could be confused.  Rename it to
    1568             :      * prevent this problem.
    1569             :      *
    1570             :      * Note no lock required on the relation, because we already hold an
    1571             :      * exclusive lock on it.
    1572             :      */
    1573        1494 :     if (!swap_toast_by_content)
    1574             :     {
    1575             :         Relation    newrel;
    1576             : 
    1577        1316 :         newrel = table_open(OIDOldHeap, NoLock);
    1578        1316 :         if (OidIsValid(newrel->rd_rel->reltoastrelid))
    1579             :         {
    1580             :             Oid         toastidx;
    1581             :             char        NewToastName[NAMEDATALEN];
    1582             : 
    1583             :             /* Get the associated valid index to be renamed */
    1584         412 :             toastidx = toast_get_valid_index(newrel->rd_rel->reltoastrelid,
    1585             :                                              NoLock);
    1586             : 
    1587             :             /* rename the toast table ... */
    1588         412 :             snprintf(NewToastName, NAMEDATALEN, "pg_toast_%u",
    1589             :                      OIDOldHeap);
    1590         412 :             RenameRelationInternal(newrel->rd_rel->reltoastrelid,
    1591             :                                    NewToastName, true, false);
    1592             : 
    1593             :             /* ... and its valid index too. */
    1594         412 :             snprintf(NewToastName, NAMEDATALEN, "pg_toast_%u_index",
    1595             :                      OIDOldHeap);
    1596             : 
    1597         412 :             RenameRelationInternal(toastidx,
    1598             :                                    NewToastName, true, true);
    1599             : 
    1600             :             /*
    1601             :              * Reset the relrewrite for the toast. The command-counter
    1602             :              * increment is required here as we are about to update the tuple
    1603             :              * that is updated as part of RenameRelationInternal.
    1604             :              */
    1605         412 :             CommandCounterIncrement();
    1606         412 :             ResetRelRewrite(newrel->rd_rel->reltoastrelid);
    1607             :         }
    1608        1316 :         relation_close(newrel, NoLock);
    1609             :     }
    1610             : 
    1611             :     /* if it's not a catalog table, clear any missing attribute settings */
    1612        1494 :     if (!is_system_catalog)
    1613             :     {
    1614             :         Relation    newrel;
    1615             : 
    1616        1292 :         newrel = table_open(OIDOldHeap, NoLock);
    1617        1292 :         RelationClearMissing(newrel);
    1618        1292 :         relation_close(newrel, NoLock);
    1619             :     }
    1620        1494 : }
    1621             : 
    1622             : 
    1623             : /*
    1624             :  * Get a list of tables that the current user has privileges on and
    1625             :  * have indisclustered set.  Return the list in a List * of RelToCluster
    1626             :  * (stored in the specified memory context), each one giving the tableOid
    1627             :  * and the indexOid on which the table is already clustered.
    1628             :  */
    1629             : static List *
    1630          30 : get_tables_to_cluster(MemoryContext cluster_context)
    1631             : {
    1632             :     Relation    indRelation;
    1633             :     TableScanDesc scan;
    1634             :     ScanKeyData entry;
    1635             :     HeapTuple   indexTuple;
    1636             :     Form_pg_index index;
    1637             :     MemoryContext old_context;
    1638          30 :     List       *rtcs = NIL;
    1639             : 
    1640             :     /*
    1641             :      * Get all indexes that have indisclustered set and that the current user
    1642             :      * has the appropriate privileges for.
    1643             :      */
    1644          30 :     indRelation = table_open(IndexRelationId, AccessShareLock);
    1645          30 :     ScanKeyInit(&entry,
    1646             :                 Anum_pg_index_indisclustered,
    1647             :                 BTEqualStrategyNumber, F_BOOLEQ,
    1648             :                 BoolGetDatum(true));
    1649          30 :     scan = table_beginscan_catalog(indRelation, 1, &entry);
    1650          48 :     while ((indexTuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
    1651             :     {
    1652             :         RelToCluster *rtc;
    1653             : 
    1654          18 :         index = (Form_pg_index) GETSTRUCT(indexTuple);
    1655             : 
    1656          18 :         if (!cluster_is_permitted_for_relation(index->indrelid, GetUserId()))
    1657          12 :             continue;
    1658             : 
    1659             :         /* Use a permanent memory context for the result list */
    1660           6 :         old_context = MemoryContextSwitchTo(cluster_context);
    1661             : 
    1662           6 :         rtc = (RelToCluster *) palloc(sizeof(RelToCluster));
    1663           6 :         rtc->tableOid = index->indrelid;
    1664           6 :         rtc->indexOid = index->indexrelid;
    1665           6 :         rtcs = lappend(rtcs, rtc);
    1666             : 
    1667           6 :         MemoryContextSwitchTo(old_context);
    1668             :     }
    1669          30 :     table_endscan(scan);
    1670             : 
    1671          30 :     relation_close(indRelation, AccessShareLock);
    1672             : 
    1673          30 :     return rtcs;
    1674             : }
    1675             : 
    1676             : /*
    1677             :  * Given an index on a partitioned table, return a list of RelToCluster for
    1678             :  * all the children leaves tables/indexes.
    1679             :  *
    1680             :  * Like expand_vacuum_rel, but here caller must hold AccessExclusiveLock
    1681             :  * on the table containing the index.
    1682             :  */
    1683             : static List *
    1684          20 : get_tables_to_cluster_partitioned(MemoryContext cluster_context, Oid indexOid)
    1685             : {
    1686             :     List       *inhoids;
    1687             :     ListCell   *lc;
    1688          20 :     List       *rtcs = NIL;
    1689             :     MemoryContext old_context;
    1690             : 
    1691             :     /* Do not lock the children until they're processed */
    1692          20 :     inhoids = find_all_inheritors(indexOid, NoLock, NULL);
    1693             : 
    1694         104 :     foreach(lc, inhoids)
    1695             :     {
    1696          84 :         Oid         indexrelid = lfirst_oid(lc);
    1697          84 :         Oid         relid = IndexGetRelation(indexrelid, false);
    1698             :         RelToCluster *rtc;
    1699             : 
    1700             :         /* consider only leaf indexes */
    1701          84 :         if (get_rel_relkind(indexrelid) != RELKIND_INDEX)
    1702          38 :             continue;
    1703             : 
    1704             :         /*
    1705             :          * It's possible that the user does not have privileges to CLUSTER the
    1706             :          * leaf partition despite having such privileges on the partitioned
    1707             :          * table.  We skip any partitions which the user is not permitted to
    1708             :          * CLUSTER.
    1709             :          */
    1710          46 :         if (!cluster_is_permitted_for_relation(relid, GetUserId()))
    1711          22 :             continue;
    1712             : 
    1713             :         /* Use a permanent memory context for the result list */
    1714          24 :         old_context = MemoryContextSwitchTo(cluster_context);
    1715             : 
    1716          24 :         rtc = (RelToCluster *) palloc(sizeof(RelToCluster));
    1717          24 :         rtc->tableOid = relid;
    1718          24 :         rtc->indexOid = indexrelid;
    1719          24 :         rtcs = lappend(rtcs, rtc);
    1720             : 
    1721          24 :         MemoryContextSwitchTo(old_context);
    1722             :     }
    1723             : 
    1724          20 :     return rtcs;
    1725             : }
    1726             : 
    1727             : /*
    1728             :  * Return whether userid has privileges to CLUSTER relid.  If not, this
    1729             :  * function emits a WARNING.
    1730             :  */
    1731             : static bool
    1732          94 : cluster_is_permitted_for_relation(Oid relid, Oid userid)
    1733             : {
    1734          94 :     if (pg_class_aclcheck(relid, userid, ACL_MAINTAIN) == ACLCHECK_OK)
    1735          60 :         return true;
    1736             : 
    1737          34 :     ereport(WARNING,
    1738             :             (errmsg("permission denied to cluster \"%s\", skipping it",
    1739             :                     get_rel_name(relid))));
    1740          34 :     return false;
    1741             : }

Generated by: LCOV version 1.14