PostgreSQL Source Code  git master
cluster.h File Reference
#include "nodes/parsenodes.h"
#include "parser/parse_node.h"
#include "storage/lock.h"
#include "utils/relcache.h"
Include dependency graph for cluster.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  ClusterParams
 

Macros

#define CLUOPT_VERBOSE   0x01 /* print progress info */
 
#define CLUOPT_RECHECK   0x02 /* recheck relation state */
 
#define CLUOPT_RECHECK_ISCLUSTERED
 

Typedefs

typedef struct ClusterParams ClusterParams
 

Functions

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

Macro Definition Documentation

◆ CLUOPT_RECHECK

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

Definition at line 24 of file cluster.h.

◆ CLUOPT_RECHECK_ISCLUSTERED

#define CLUOPT_RECHECK_ISCLUSTERED
Value:
0x04 /* recheck relation state for
* indisclustered */

Definition at line 25 of file cluster.h.

◆ CLUOPT_VERBOSE

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

Definition at line 23 of file cluster.h.

Typedef Documentation

◆ ClusterParams

typedef struct ClusterParams ClusterParams

Function Documentation

◆ check_index_is_clusterable()

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

Definition at line 500 of file cluster.c.

501 {
502  Relation OldIndex;
503 
504  OldIndex = index_open(indexOid, lockmode);
505 
506  /*
507  * Check that index is in fact an index on the given relation
508  */
509  if (OldIndex->rd_index == NULL ||
510  OldIndex->rd_index->indrelid != RelationGetRelid(OldHeap))
511  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  if (!OldIndex->rd_indam->amclusterable)
519  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  if (!heap_attisnull(OldIndex->rd_indextuple, Anum_pg_index_indpred, NULL))
531  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  if (!OldIndex->rd_index->indisvalid)
545  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  index_close(OldIndex, NoLock);
552 }
int errcode(int sqlerrcode)
Definition: elog.c:859
int errmsg(const char *fmt,...)
Definition: elog.c:1072
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
bool heap_attisnull(HeapTuple tup, int attnum, TupleDesc tupleDesc)
Definition: heaptuple.c:455
void index_close(Relation relation, LOCKMODE lockmode)
Definition: indexam.c:177
Relation index_open(Oid relationId, LOCKMODE lockmode)
Definition: indexam.c:133
#define NoLock
Definition: lockdefs.h:34
#define RelationGetRelid(relation)
Definition: rel.h:505
#define RelationGetRelationName(relation)
Definition: rel.h:539
bool amclusterable
Definition: amapi.h:241
struct IndexAmRoutine * rd_indam
Definition: rel.h:206
struct HeapTupleData * rd_indextuple
Definition: rel.h:194
Form_pg_index rd_index
Definition: rel.h:192

References IndexAmRoutine::amclusterable, ereport, errcode(), errmsg(), ERROR, heap_attisnull(), index_close(), index_open(), NoLock, RelationData::rd_indam, RelationData::rd_index, RelationData::rd_indextuple, RelationGetRelationName, and RelationGetRelid.

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

◆ cluster()

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

Definition at line 108 of file cluster.c.

109 {
110  ListCell *lc;
111  ClusterParams params = {0};
112  bool verbose = false;
113  Relation rel = NULL;
114  Oid indexOid = InvalidOid;
115  MemoryContext cluster_context;
116  List *rtcs;
117 
118  /* Parse option list */
119  foreach(lc, stmt->params)
120  {
121  DefElem *opt = (DefElem *) lfirst(lc);
122 
123  if (strcmp(opt->defname, "verbose") == 0)
124  verbose = defGetBoolean(opt);
125  else
126  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  params.options = (verbose ? CLUOPT_VERBOSE : 0);
134 
135  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  tableOid = RangeVarGetRelidExtended(stmt->relation,
147  0,
149  NULL);
150  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  if (RELATION_IS_OTHER_TEMP(rel))
157  ereport(ERROR,
158  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
159  errmsg("cannot cluster temporary tables of other sessions")));
160 
161  if (stmt->indexname == NULL)
162  {
163  ListCell *index;
164 
165  /* We need to find the index that has indisclustered set. */
166  foreach(index, RelationGetIndexList(rel))
167  {
168  indexOid = lfirst_oid(index);
169  if (get_index_isclustered(indexOid))
170  break;
171  indexOid = InvalidOid;
172  }
173 
174  if (!OidIsValid(indexOid))
175  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  indexOid = get_relname_relid(stmt->indexname,
187  rel->rd_rel->relnamespace);
188  if (!OidIsValid(indexOid))
189  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  if (rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
196  {
197  /* close relation, keep lock till commit */
198  table_close(rel, NoLock);
199 
200  /* Do the job. */
201  cluster_rel(tableOid, indexOid, &params);
202 
203  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  PreventInTransactionBlock(isTopLevel, "CLUSTER");
214 
215  /* Also, we need a memory context to hold our list of relations */
216  cluster_context = AllocSetContextCreate(PortalContext,
217  "Cluster",
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  params.options |= CLUOPT_RECHECK;
233  if (rel != NULL)
234  {
235  Assert(rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
237  rtcs = get_tables_to_cluster_partitioned(cluster_context, indexOid);
238 
239  /* close relation, releasing lock on parent table */
241  }
242  else
243  {
244  rtcs = get_tables_to_cluster(cluster_context);
246  }
247 
248  /* Do the job. */
249  cluster_multiple_rels(rtcs, &params);
250 
251  /* Start a new transaction for the cleanup work. */
253 
254  /* Clean up working storage */
255  MemoryContextDelete(cluster_context);
256 }
#define Assert(condition)
Definition: c.h:858
#define OidIsValid(objectId)
Definition: c.h:775
void cluster_rel(Oid tableOid, Oid indexOid, ClusterParams *params)
Definition: cluster.c:311
void check_index_is_clusterable(Relation OldHeap, Oid indexOid, LOCKMODE lockmode)
Definition: cluster.c:500
static List * get_tables_to_cluster(MemoryContext cluster_context)
Definition: cluster.c:1630
static List * get_tables_to_cluster_partitioned(MemoryContext cluster_context, Oid indexOid)
Definition: cluster.c:1684
static void cluster_multiple_rels(List *rtcs, ClusterParams *params)
Definition: cluster.c:266
#define CLUOPT_VERBOSE
Definition: cluster.h:23
#define CLUOPT_RECHECK_ISCLUSTERED
Definition: cluster.h:25
#define CLUOPT_RECHECK
Definition: cluster.h:24
bool defGetBoolean(DefElem *def)
Definition: define.c:107
#define stmt
Definition: indent_codes.h:59
int verbose
#define AccessExclusiveLock
Definition: lockdefs.h:43
#define AccessShareLock
Definition: lockdefs.h:36
bool get_index_isclustered(Oid index_oid)
Definition: lsyscache.c:3601
Oid get_relname_relid(const char *relname, Oid relnamespace)
Definition: lsyscache.c:1885
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:454
MemoryContext PortalContext
Definition: mcxt.c:158
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160
Oid RangeVarGetRelidExtended(const RangeVar *relation, LOCKMODE lockmode, uint32 flags, RangeVarGetRelidCallback callback, void *callback_arg)
Definition: namespace.c:426
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:106
#define lfirst(lc)
Definition: pg_list.h:172
#define lfirst_oid(lc)
Definition: pg_list.h:174
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
#define RELATION_IS_OTHER_TEMP(relation)
Definition: rel.h:658
List * RelationGetIndexList(Relation relation)
Definition: relcache.c:4760
bits32 options
Definition: cluster.h:30
char * defname
Definition: parsenodes.h:815
ParseLoc location
Definition: parsenodes.h:819
Definition: pg_list.h:54
Form_pg_class rd_rel
Definition: rel.h:111
Definition: type.h:95
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40
void RangeVarCallbackMaintainsTable(const RangeVar *relation, Oid relId, Oid oldRelId, void *arg)
Definition: tablecmds.c:18362
void PreventInTransactionBlock(bool isTopLevel, const char *stmtType)
Definition: xact.c:3584
void StartTransactionCommand(void)
Definition: xact.c:2995

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

Referenced by adjust_data_dir(), check_bin_dir(), check_data_dir(), check_for_data_types_usage(), check_for_incompatible_polymorphics(), check_for_isn_and_int8_passing_mismatch(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_for_tables_with_oids(), check_for_user_defined_encoding_conversions(), check_for_user_defined_postfix_ops(), check_is_install_user(), check_proper_datallowconn(), cluster_conn_opts(), connectToServer(), get_bin_version(), get_control_data(), get_db_conn(), get_db_infos(), get_db_rel_and_slot_infos(), get_major_server_version(), get_rel_infos(), get_sock_dir(), get_template0_info(), jsonb_9_4_check_applicable(), old_9_6_invalidate_hash_indexes(), report_extension_updates(), set_tablespace_directory_suffix(), standard_ProcessUtility(), start_postmaster(), and stop_postmaster().

◆ cluster_rel()

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

Definition at line 311 of file cluster.c.

312 {
313  Relation OldHeap;
314  Oid save_userid;
315  int save_sec_context;
316  int save_nestlevel;
317  bool verbose = ((params->options & CLUOPT_VERBOSE) != 0);
318  bool recheck = ((params->options & CLUOPT_RECHECK) != 0);
319 
320  /* Check for user-requested abort. */
322 
324  if (OidIsValid(indexOid))
327  else
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  OldHeap = try_relation_open(tableOid, AccessExclusiveLock);
338 
339  /* If the table has gone away, we can skip processing it */
340  if (!OldHeap)
341  {
343  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  GetUserIdAndSecContext(&save_userid, &save_sec_context);
352  SetUserIdAndSecContext(OldHeap->rd_rel->relowner,
353  save_sec_context | SECURITY_RESTRICTED_OPERATION);
354  save_nestlevel = NewGUCNestLevel();
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  if (recheck)
366  {
367  /* Check that the user still has privileges for the relation */
368  if (!cluster_is_permitted_for_relation(tableOid, save_userid))
369  {
371  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  if (RELATION_IS_OTHER_TEMP(OldHeap))
384  {
386  goto out;
387  }
388 
389  if (OidIsValid(indexOid))
390  {
391  /*
392  * Check that the index still exists
393  */
394  if (!SearchSysCacheExists1(RELOID, ObjectIdGetDatum(indexOid)))
395  {
397  goto out;
398  }
399 
400  /*
401  * Check that the index is still the one with indisclustered set,
402  * if needed.
403  */
404  if ((params->options & CLUOPT_RECHECK_ISCLUSTERED) != 0 &&
405  !get_index_isclustered(indexOid))
406  {
408  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  if (OidIsValid(indexOid) && OldHeap->rd_rel->relisshared)
420  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  if (RELATION_IS_OTHER_TEMP(OldHeap))
429  {
430  if (OidIsValid(indexOid))
431  ereport(ERROR,
432  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
433  errmsg("cannot cluster temporary tables of other sessions")));
434  else
435  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  CheckTableNotInUse(OldHeap, OidIsValid(indexOid) ? "CLUSTER" : "VACUUM");
445 
446  /* Check heap and index are valid to cluster on */
447  if (OidIsValid(indexOid))
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  if (OldHeap->rd_rel->relkind == RELKIND_MATVIEW &&
458  !RelationIsPopulated(OldHeap))
459  {
461  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  */
475 
476  /* rebuild_relation does all the dirty work */
477  rebuild_relation(OldHeap, indexOid, verbose);
478 
479  /* NB: rebuild_relation does table_close() on OldHeap */
480 
481 out:
482  /* Roll back any GUC changes executed by index functions */
483  AtEOXact_GUC(false, save_nestlevel);
484 
485  /* Restore userid and security context */
486  SetUserIdAndSecContext(save_userid, save_sec_context);
487 
489 }
void pgstat_progress_start_command(ProgressCommandType cmdtype, Oid relid)
void pgstat_progress_update_param(int index, int64 val)
void pgstat_progress_end_command(void)
@ PROGRESS_COMMAND_CLUSTER
static void rebuild_relation(Relation OldHeap, Oid indexOid, bool verbose)
Definition: cluster.c:633
static bool cluster_is_permitted_for_relation(Oid relid, Oid userid)
Definition: cluster.c:1732
int NewGUCNestLevel(void)
Definition: guc.c:2237
void RestrictSearchPath(void)
Definition: guc.c:2248
void AtEOXact_GUC(bool isCommit, int nestLevel)
Definition: guc.c:2264
#define SECURITY_RESTRICTED_OPERATION
Definition: miscadmin.h:315
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
void GetUserIdAndSecContext(Oid *userid, int *sec_context)
Definition: miscinit.c:635
void SetUserIdAndSecContext(Oid userid, int sec_context)
Definition: miscinit.c:642
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
void TransferPredicateLocksToHeapRelation(Relation relation)
Definition: predicate.c:3108
#define PROGRESS_CLUSTER_COMMAND_VACUUM_FULL
Definition: progress.h:77
#define PROGRESS_CLUSTER_COMMAND_CLUSTER
Definition: progress.h:76
#define PROGRESS_CLUSTER_COMMAND
Definition: progress.h:57
#define RelationIsPopulated(relation)
Definition: rel.h:677
void relation_close(Relation relation, LOCKMODE lockmode)
Definition: relation.c:205
Relation try_relation_open(Oid relationId, LOCKMODE lockmode)
Definition: relation.c:88
#define SearchSysCacheExists1(cacheId, key1)
Definition: syscache.h:95
void CheckTableNotInUse(Relation rel, const char *stmt)
Definition: tablecmds.c:4345

References AccessExclusiveLock, Assert, AtEOXact_GUC(), CHECK_FOR_INTERRUPTS, check_index_is_clusterable(), CheckTableNotInUse(), CLUOPT_RECHECK, CLUOPT_RECHECK_ISCLUSTERED, CLUOPT_VERBOSE, cluster_is_permitted_for_relation(), ereport, errcode(), errmsg(), ERROR, get_index_isclustered(), GetUserIdAndSecContext(), NewGUCNestLevel(), ObjectIdGetDatum(), OidIsValid, ClusterParams::options, pgstat_progress_end_command(), pgstat_progress_start_command(), pgstat_progress_update_param(), PROGRESS_CLUSTER_COMMAND, PROGRESS_CLUSTER_COMMAND_CLUSTER, PROGRESS_CLUSTER_COMMAND_VACUUM_FULL, PROGRESS_COMMAND_CLUSTER, RelationData::rd_rel, rebuild_relation(), relation_close(), RELATION_IS_OTHER_TEMP, RelationIsPopulated, RestrictSearchPath(), SearchSysCacheExists1, SECURITY_RESTRICTED_OPERATION, SetUserIdAndSecContext(), TransferPredicateLocksToHeapRelation(), try_relation_open(), and verbose.

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

◆ finish_heap_swap()

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

Definition at line 1432 of file cluster.c.

1440 {
1441  ObjectAddress object;
1442  Oid mapped_tables[4];
1443  int reindex_flags;
1444  ReindexParams reindex_params = {0};
1445  int i;
1446 
1447  /* Report that we are now swapping relation files */
1450 
1451  /* Zero out possible results from swapped_relation_files */
1452  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  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  if (is_system_catalog)
1468  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  reindex_flags = REINDEX_REL_SUPPRESS_INDEX_USE;
1486  if (check_constraints)
1487  reindex_flags |= REINDEX_REL_CHECK_CONSTRAINTS;
1488 
1489  /*
1490  * Ensure that the indexes have the same persistence as the parent
1491  * relation.
1492  */
1493  if (newrelpersistence == RELPERSISTENCE_UNLOGGED)
1494  reindex_flags |= REINDEX_REL_FORCE_INDEXES_UNLOGGED;
1495  else if (newrelpersistence == RELPERSISTENCE_PERMANENT)
1496  reindex_flags |= REINDEX_REL_FORCE_INDEXES_PERMANENT;
1497 
1498  /* Report that we are now reindexing relations */
1501 
1502  reindex_relation(NULL, OIDOldHeap, reindex_flags, &reindex_params);
1503 
1504  /* Report that we are now doing clean up */
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  if (OIDOldHeap == RelationRelationId)
1521  {
1522  Relation relRelation;
1523  HeapTuple reltup;
1524  Form_pg_class relform;
1525 
1526  relRelation = table_open(RelationRelationId, RowExclusiveLock);
1527 
1528  reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
1529  if (!HeapTupleIsValid(reltup))
1530  elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
1531  relform = (Form_pg_class) GETSTRUCT(reltup);
1532 
1533  relform->relfrozenxid = frozenXid;
1534  relform->relminmxid = cutoffMulti;
1535 
1536  CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
1537 
1538  table_close(relRelation, RowExclusiveLock);
1539  }
1540 
1541  /* Destroy new heap with old filenumber */
1542  object.classId = RelationRelationId;
1543  object.objectId = OIDNewHeap;
1544  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  */
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  for (i = 0; OidIsValid(mapped_tables[i]); i++)
1561  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  if (!swap_toast_by_content)
1574  {
1575  Relation newrel;
1576 
1577  newrel = table_open(OIDOldHeap, NoLock);
1578  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  toastidx = toast_get_valid_index(newrel->rd_rel->reltoastrelid,
1585  NoLock);
1586 
1587  /* rename the toast table ... */
1588  snprintf(NewToastName, NAMEDATALEN, "pg_toast_%u",
1589  OIDOldHeap);
1590  RenameRelationInternal(newrel->rd_rel->reltoastrelid,
1591  NewToastName, true, false);
1592 
1593  /* ... and its valid index too. */
1594  snprintf(NewToastName, NAMEDATALEN, "pg_toast_%u_index",
1595  OIDOldHeap);
1596 
1597  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  */
1606  ResetRelRewrite(newrel->rd_rel->reltoastrelid);
1607  }
1608  relation_close(newrel, NoLock);
1609  }
1610 
1611  /* if it's not a catalog table, clear any missing attribute settings */
1612  if (!is_system_catalog)
1613  {
1614  Relation newrel;
1615 
1616  newrel = table_open(OIDOldHeap, NoLock);
1617  RelationClearMissing(newrel);
1618  relation_close(newrel, NoLock);
1619  }
1620 }
static void swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class, bool swap_toast_by_content, bool is_internal, TransactionId frozenXid, MultiXactId cutoffMulti, Oid *mapped_tables)
Definition: cluster.c:1055
void performDeletion(const ObjectAddress *object, DropBehavior behavior, int flags)
Definition: dependency.c:273
#define PERFORM_DELETION_INTERNAL
Definition: dependency.h:85
#define elog(elevel,...)
Definition: elog.h:224
void RelationClearMissing(Relation rel)
Definition: heap.c:1937
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
bool reindex_relation(const ReindexStmt *stmt, Oid relid, int flags, const ReindexParams *params)
Definition: index.c:3889
#define REINDEX_REL_FORCE_INDEXES_UNLOGGED
Definition: index.h:162
#define REINDEX_REL_SUPPRESS_INDEX_USE
Definition: index.h:160
#define REINDEX_REL_FORCE_INDEXES_PERMANENT
Definition: index.h:163
#define REINDEX_REL_CHECK_CONSTRAINTS
Definition: index.h:161
void CatalogTupleUpdate(Relation heapRel, ItemPointer otid, HeapTuple tup)
Definition: indexing.c:313
void CacheInvalidateCatalog(Oid catalogId)
Definition: inval.c:1336
int i
Definition: isn.c:73
#define RowExclusiveLock
Definition: lockdefs.h:38
@ DROP_RESTRICT
Definition: parsenodes.h:2334
FormData_pg_class * Form_pg_class
Definition: pg_class.h:153
#define NAMEDATALEN
#define snprintf
Definition: port.h:238
#define PROGRESS_CLUSTER_PHASE
Definition: progress.h:58
#define PROGRESS_CLUSTER_PHASE_REBUILD_INDEX
Definition: progress.h:72
#define PROGRESS_CLUSTER_PHASE_FINAL_CLEANUP
Definition: progress.h:73
#define PROGRESS_CLUSTER_PHASE_SWAP_REL_FILES
Definition: progress.h:71
void RelationMapRemoveMapping(Oid relationId)
Definition: relmapper.c:438
ItemPointerData t_self
Definition: htup.h:65
#define SearchSysCacheCopy1(cacheId, key1)
Definition: syscache.h:86
void ResetRelRewrite(Oid myrelid)
Definition: tablecmds.c:4292
void RenameRelationInternal(Oid myrelid, const char *newrelname, bool is_internal, bool is_index)
Definition: tablecmds.c:4202
Oid toast_get_valid_index(Oid toastoid, LOCKMODE lock)
void CommandCounterIncrement(void)
Definition: xact.c:1097

References CacheInvalidateCatalog(), CatalogTupleUpdate(), CommandCounterIncrement(), DROP_RESTRICT, elog, ERROR, GETSTRUCT, HeapTupleIsValid, i, NAMEDATALEN, NoLock, ObjectIdGetDatum(), OidIsValid, PERFORM_DELETION_INTERNAL, performDeletion(), pgstat_progress_update_param(), PROGRESS_CLUSTER_PHASE, PROGRESS_CLUSTER_PHASE_FINAL_CLEANUP, PROGRESS_CLUSTER_PHASE_REBUILD_INDEX, PROGRESS_CLUSTER_PHASE_SWAP_REL_FILES, RelationData::rd_rel, REINDEX_REL_CHECK_CONSTRAINTS, REINDEX_REL_FORCE_INDEXES_PERMANENT, REINDEX_REL_FORCE_INDEXES_UNLOGGED, REINDEX_REL_SUPPRESS_INDEX_USE, reindex_relation(), relation_close(), RelationClearMissing(), RelationMapRemoveMapping(), RenameRelationInternal(), ResetRelRewrite(), RowExclusiveLock, SearchSysCacheCopy1, snprintf, swap_relation_files(), HeapTupleData::t_self, table_close(), table_open(), and toast_get_valid_index().

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

◆ make_new_heap()

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

Definition at line 688 of file cluster.c.

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  OldHeap = table_open(OIDOldHeap, lockmode);
702  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  tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(OIDOldHeap));
715  if (!HeapTupleIsValid(tuple))
716  elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
717  reloptions = SysCacheGetAttr(RELOID, tuple, Anum_pg_class_reloptions,
718  &isNull);
719  if (isNull)
720  reloptions = (Datum) 0;
721 
722  if (relpersistence == RELPERSISTENCE_TEMP)
723  namespaceid = LookupCreationNamespace("pg_temp");
724  else
725  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  snprintf(NewHeapName, sizeof(NewHeapName), "pg_temp_%u", OIDOldHeap);
740 
741  OIDNewHeap = heap_create_with_catalog(NewHeapName,
742  namespaceid,
743  NewTableSpace,
744  InvalidOid,
745  InvalidOid,
746  InvalidOid,
747  OldHeap->rd_rel->relowner,
748  NewAccessMethod,
749  OldHeapDesc,
750  NIL,
751  RELKIND_RELATION,
752  relpersistence,
753  false,
754  RelationIsMapped(OldHeap),
756  reloptions,
757  false,
758  true,
759  true,
760  OIDOldHeap,
761  NULL);
762  Assert(OIDNewHeap != InvalidOid);
763 
764  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  */
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  toastid = OldHeap->rd_rel->reltoastrelid;
784  if (OidIsValid(toastid))
785  {
786  /* keep the existing toast table's reloptions, if any */
787  tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(toastid));
788  if (!HeapTupleIsValid(tuple))
789  elog(ERROR, "cache lookup failed for relation %u", toastid);
790  reloptions = SysCacheGetAttr(RELOID, tuple, Anum_pg_class_reloptions,
791  &isNull);
792  if (isNull)
793  reloptions = (Datum) 0;
794 
795  NewHeapCreateToastTable(OIDNewHeap, reloptions, lockmode, toastid);
796 
797  ReleaseSysCache(tuple);
798  }
799 
800  table_close(OldHeap, NoLock);
801 
802  return OIDNewHeap;
803 }
Oid heap_create_with_catalog(const char *relname, Oid relnamespace, Oid reltablespace, Oid relid, Oid reltypeid, Oid reloftypeid, Oid ownerid, Oid accessmtd, TupleDesc tupdesc, List *cooked_constraints, char relkind, char relpersistence, bool shared_relation, bool mapped_relation, OnCommitAction oncommit, Datum reloptions, bool use_user_acl, bool allow_system_table_mods, bool is_internal, Oid relrewrite, ObjectAddress *typaddress)
Definition: heap.c:1104
Oid LookupCreationNamespace(const char *nspname)
Definition: namespace.c:3413
#define NIL
Definition: pg_list.h:68
uintptr_t Datum
Definition: postgres.h:64
@ ONCOMMIT_NOOP
Definition: primnodes.h:57
#define RelationGetDescr(relation)
Definition: rel.h:531
#define RelationIsMapped(relation)
Definition: rel.h:554
#define RelationGetNamespace(relation)
Definition: rel.h:546
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:266
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:218
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Definition: syscache.c:479
void NewHeapCreateToastTable(Oid relOid, Datum reloptions, LOCKMODE lockmode, Oid OIDOldToast)
Definition: toasting.c:63

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

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

◆ mark_index_clustered()

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

Definition at line 560 of file cluster.c.

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  if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
569  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  if (OidIsValid(indexOid))
577  {
578  if (get_index_isclustered(indexOid))
579  return;
580  }
581 
582  /*
583  * Check each index of the relation and set/clear the bit as needed.
584  */
585  pg_index = table_open(IndexRelationId, RowExclusiveLock);
586 
587  foreach(index, RelationGetIndexList(rel))
588  {
589  Oid thisIndexOid = lfirst_oid(index);
590 
591  indexTuple = SearchSysCacheCopy1(INDEXRELID,
592  ObjectIdGetDatum(thisIndexOid));
593  if (!HeapTupleIsValid(indexTuple))
594  elog(ERROR, "cache lookup failed for index %u", thisIndexOid);
595  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  if (indexForm->indisclustered)
602  {
603  indexForm->indisclustered = false;
604  CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
605  }
606  else if (thisIndexOid == indexOid)
607  {
608  /* this was checked earlier, but let's be real sure */
609  if (!indexForm->indisvalid)
610  elog(ERROR, "cannot cluster on invalid index %u", indexOid);
611  indexForm->indisclustered = true;
612  CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
613  }
614 
615  InvokeObjectPostAlterHookArg(IndexRelationId, thisIndexOid, 0,
616  InvalidOid, is_internal);
617 
618  heap_freetuple(indexTuple);
619  }
620 
621  table_close(pg_index, RowExclusiveLock);
622 }
void heap_freetuple(HeapTuple htup)
Definition: heaptuple.c:1434
#define InvokeObjectPostAlterHookArg(classId, objectId, subId, auxiliaryId, is_internal)
Definition: objectaccess.h:200
FormData_pg_index * Form_pg_index
Definition: pg_index.h:70

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

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