Loading...
Searching...
No Matches
cluster.c File Reference
#include "postgres.h"#include "access/amapi.h"#include "access/heapam.h"#include "access/multixact.h"#include "access/relscan.h"#include "access/tableam.h"#include "access/toast_internals.h"#include "access/transam.h"#include "access/xact.h"#include "catalog/catalog.h"#include "catalog/dependency.h"#include "catalog/heap.h"#include "catalog/index.h"#include "catalog/namespace.h"#include "catalog/objectaccess.h"#include "catalog/pg_am.h"#include "catalog/pg_inherits.h"#include "catalog/toasting.h"#include "commands/cluster.h"#include "commands/defrem.h"#include "commands/progress.h"#include "commands/tablecmds.h"#include "commands/vacuum.h"#include "miscadmin.h"#include "optimizer/optimizer.h"#include "pgstat.h"#include "storage/bufmgr.h"#include "storage/lmgr.h"#include "storage/predicate.h"#include "utils/acl.h"#include "utils/fmgroids.h"#include "utils/guc.h"#include "utils/inval.h"#include "utils/lsyscache.h"#include "utils/memutils.h"#include "utils/pg_rusage.h"#include "utils/relmapper.h"#include "utils/snapmgr.h"#include "utils/syscache.h"
Include dependency graph for cluster.c:
Go to the source code of this file.
Data Structures | |
| struct | RelToCluster |
Function Documentation
◆ check_index_is_clusterable()
Definition at line 508 of file cluster.c.
509{
511
513
514 /*
515 * Check that index is in fact an index on the given relation
516 */
524
525 /* Index AM must allow clustering */
531
532 /*
533 * Disallow clustering on incomplete indexes (those that might not index
534 * every row of the relation). We could relax this by making a separate
535 * seqscan pass over the table to copy the missing rows, but that seems
536 * expensive and tedious.
537 */
543
544 /*
545 * Disallow if index is left over from a failed CREATE INDEX CONCURRENTLY;
546 * it might well not contain entries for every heap row, or might not even
547 * be internally consistent. (But note that we don't check indcheckxmin;
548 * the worst consequence of following broken HOT chains would be that we
549 * might put recently-dead tuples out-of-order in the new table, and there
550 * is little harm in that.)
551 */
557
558 /* Drop relcache refcnt on OldIndex, but keep lock */
560}
bool heap_attisnull(HeapTuple tup, int attnum, TupleDesc tupleDesc)
Definition heaptuple.c:456
Definition rel.h:56
References ereport, errcode(), errmsg, ERROR, fb(), heap_attisnull(), index_close(), index_open(), NoLock, RelationGetRelationName, and RelationGetRelid.
Referenced by ATExecClusterOn(), cluster_rel(), ExecRepack(), and process_single_relation().
◆ cluster_rel()
| void cluster_rel | ( | RepackCommand | cmd, |
| Relation | OldHeap, | ||
| Oid | indexOid, | ||
| ClusterParams * | params | ||
| ) |
Definition at line 300 of file cluster.c.
302{
304 Oid save_userid;
305 int save_sec_context;
306 int save_nestlevel;
310
312
313 /* Check for user-requested abort. */
314 CHECK_FOR_INTERRUPTS();
315
318
319 /*
320 * Switch to the table owner's userid, so that any index functions are run
321 * as that user. Also lock down security-restricted operations and
322 * arrange to make GUC variable changes local to this command.
323 */
324 GetUserIdAndSecContext(&save_userid, &save_sec_context);
326 save_sec_context | SECURITY_RESTRICTED_OPERATION);
327 save_nestlevel = NewGUCNestLevel();
328 RestrictSearchPath();
329
330 /*
331 * Since we may open a new transaction for each relation, we have to check
332 * that the relation still is what we think it is.
333 *
334 * If this is a single-transaction CLUSTER, we can skip these tests. We
335 * *must* skip the one on indisclustered since it would reject an attempt
336 * to cluster a not-previously-clustered index.
337 */
338 if (recheck &&
340 params->options))
341 goto out;
342
343 /*
344 * We allow repacking shared catalogs only when not using an index. It
345 * would work to use an index in most respects, but the index would only
346 * get marked as indisclustered in the current database, leading to
347 * unexpected behavior if CLUSTER were later invoked in another database.
348 */
352 /*- translator: first %s is name of a SQL command, eg. REPACK */
354 RepackCommandAsString(cmd)));
355
356 /*
357 * Don't process temp tables of other backends ... their local buffer
358 * manager is not going to cope.
359 */
363 /*- translator: first %s is name of a SQL command, eg. REPACK */
365 RepackCommandAsString(cmd)));
366
367 /*
368 * Also check for active uses of the relation in the current transaction,
369 * including open scans and pending AFTER trigger events.
370 */
372
373 /* Check heap and index are valid to cluster on */
375 {
376 /* verify the index is good and lock it */
378 /* also open it */
380 }
381 else
383
384 /*
385 * When allow_system_table_mods is turned off, we disallow repacking a
386 * catalog on a particular index unless that's already the clustered index
387 * for that catalog.
388 *
389 * XXX We don't check for this in CLUSTER, because it's historically been
390 * allowed.
391 */
399 errdetail("System catalogs can only be clustered by the index they're already clustered on, if any, unless \"%s\" is enabled.",
400 "allow_system_table_mods"));
401
402 /*
403 * Quietly ignore the request if this is a materialized view which has not
404 * been populated from its query. No harm is done because there is no data
405 * to deal with, and we don't want to throw an error if this is part of a
406 * multi-relation request -- for example, CLUSTER was run on the entire
407 * database.
408 */
411 {
413 goto out;
414 }
415
419
420 /*
421 * All predicate locks on the tuples or pages are about to be made
422 * invalid, because we move tuples around. Promote them to relation
423 * locks. Predicate locks on indexes will be promoted when they are
424 * reindexed.
425 */
427
428 /* rebuild_relation does all the dirty work */
430 /* rebuild_relation closes OldHeap, and index if valid */
431
432out:
433 /* Roll back any GUC changes executed by index functions */
435
436 /* Restore userid and security context */
437 SetUserIdAndSecContext(save_userid, save_sec_context);
438
439 pgstat_progress_end_command();
440}
void pgstat_progress_start_command(ProgressCommandType cmdtype, Oid relid)
Definition backend_progress.c:28
void pgstat_progress_update_param(int index, int64 val)
Definition backend_progress.c:49
void check_index_is_clusterable(Relation OldHeap, Oid indexOid, LOCKMODE lockmode)
Definition cluster.c:508
static const char * RepackCommandAsString(RepackCommand cmd)
Definition cluster.c:2015
static bool cluster_rel_recheck(RepackCommand cmd, Relation OldHeap, Oid indexOid, Oid userid, int options)
Definition cluster.c:447
static void rebuild_relation(Relation OldHeap, Relation index, bool verbose)
Definition cluster.c:639
int errdetail(const char *fmt,...) pg_attribute_printf(1
bool CheckRelationLockedByMe(Relation relation, LOCKMODE lockmode, bool orstronger)
Definition lmgr.c:334
void GetUserIdAndSecContext(Oid *userid, int *sec_context)
Definition miscinit.c:613
void SetUserIdAndSecContext(Oid userid, int sec_context)
Definition miscinit.c:620
void TransferPredicateLocksToHeapRelation(Relation relation)
Definition predicate.c:3132
void CheckTableNotInUse(Relation rel, const char *stmt)
Definition tablecmds.c:4447
References AccessExclusiveLock, allowSystemTableMods, Assert, AtEOXact_GUC(), CHECK_FOR_INTERRUPTS, check_index_is_clusterable(), CheckRelationLockedByMe(), CheckTableNotInUse(), CLUOPT_RECHECK, CLUOPT_VERBOSE, cluster_rel_recheck(), ereport, errcode(), errdetail(), errmsg, ERROR, fb(), GetUserIdAndSecContext(), index_open(), IsCatalogRelation(), NewGUCNestLevel(), NoLock, OidIsValid, ClusterParams::options, pgstat_progress_end_command(), pgstat_progress_start_command(), pgstat_progress_update_param(), PROGRESS_COMMAND_REPACK, PROGRESS_REPACK_COMMAND, rebuild_relation(), relation_close(), RELATION_IS_OTHER_TEMP, RelationGetRelationName, RelationGetRelid, RelationIsPopulated, REPACK_COMMAND_CLUSTER, RepackCommandAsString(), RestrictSearchPath(), SECURITY_RESTRICTED_OPERATION, SetUserIdAndSecContext(), TransferPredicateLocksToHeapRelation(), and verbose.
Referenced by ExecRepack(), process_single_relation(), and vacuum_rel().
◆ cluster_rel_recheck()
|
static |
Definition at line 447 of file cluster.c.
449{
451
452 /* Check that the user still has privileges for the relation */
454 {
456 return false;
457 }
458
459 /*
460 * Silently skip a temp table for a remote session. Only doing this check
461 * in the "recheck" case is appropriate (which currently means somebody is
462 * executing a database-wide CLUSTER or on a partitioned table), because
463 * there is another check in cluster() which will stop any attempt to
464 * cluster remote temp tables by name. There is another check in
465 * cluster_rel which is redundant, but we leave it for extra safety.
466 */
468 {
470 return false;
471 }
472
474 {
475 /*
476 * Check that the index still exists
477 */
479 {
481 return false;
482 }
483
484 /*
485 * Check that the index is still the one with indisclustered set, if
486 * needed.
487 */
489 !get_index_isclustered(indexOid))
490 {
492 return false;
493 }
494 }
495
496 return true;
497}
static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid)
Definition cluster.c:1851
Definition oid2name.c:30
References AccessExclusiveLock, CLUOPT_RECHECK_ISCLUSTERED, fb(), get_index_isclustered(), ObjectIdGetDatum(), OidIsValid, relation_close(), RELATION_IS_OTHER_TEMP, RelationGetRelid, repack_is_permitted_for_relation(), and SearchSysCacheExists1.
Referenced by cluster_rel().
◆ copy_table_data()
|
static |
Definition at line 841 of file cluster.c.
844{
850 VacuumParams params;
853 double num_tuples = 0,
854 tups_vacuumed = 0,
855 tups_recently_dead = 0;
856 BlockNumber num_pages;
859 char *nspname;
860
862
863 /* Store a copy of the namespace name for logging purposes */
865
866 /*
867 * Their tuple descriptors should be exactly alike, but here we only need
868 * assume that they have the same number of columns.
869 */
873
874 /*
875 * If the OldHeap has a toast table, get lock on the toast table to keep
876 * it from being vacuumed. This is needed because autovacuum processes
877 * toast tables independently of their main tables, with no lock on the
878 * latter. If an autovacuum were to start on the toast table after we
879 * compute our OldestXmin below, it would use a later OldestXmin, and then
880 * possibly remove as DEAD toast tuples belonging to main tuples we think
881 * are only RECENTLY_DEAD. Then we'd fail while trying to copy those
882 * tuples.
883 *
884 * We don't need to open the toast relation here, just lock it. The lock
885 * will be held till end of transaction.
886 */
889
890 /*
891 * If both tables have TOAST tables, perform toast swap by content. It is
892 * possible that the old table has a toast table but the new one doesn't,
893 * if toastable columns have been dropped. In that case we have to do
894 * swap by links. This is okay because swap by content is only essential
895 * for system catalogs, and we don't support schema changes for them.
896 */
898 {
900
901 /*
902 * When doing swap by content, any toast pointers written into NewHeap
903 * must use the old toast table's OID, because that's where the toast
904 * data will eventually be found. Set this up by setting rd_toastoid.
905 * This also tells toast_save_datum() to preserve the toast value
906 * OIDs, which we want so as not to invalidate toast pointers in
907 * system catalog caches, and to avoid making multiple copies of a
908 * single toast value.
909 *
910 * Note that we must hold NewHeap open until we are done writing data,
911 * since the relcache will not guarantee to remember this setting once
912 * the relation is closed. Also, this technique depends on the fact
913 * that no one will try to read from the NewHeap until after we've
914 * finished writing it and swapping the rels --- otherwise they could
915 * follow the toast pointers to the wrong place. (It would actually
916 * work for values copied over from the old toast table, but not for
917 * any values that we toast which were previously not toasted.)
918 */
920 }
921 else
923
924 /*
925 * Compute xids used to freeze and weed out dead tuples and multixacts.
926 * Since we're going to rewrite the whole table anyway, there's no reason
927 * not to be aggressive about this.
928 */
931
932 /*
933 * FreezeXid will become the table's new relfrozenxid, and that mustn't go
934 * backwards, so take the max.
935 */
936 {
938
941 cutoffs.FreezeLimit = relfrozenxid;
942 }
943
944 /*
945 * MultiXactCutoff, similarly, shouldn't go backwards either.
946 */
947 {
949
952 cutoffs.MultiXactCutoff = relminmxid;
953 }
954
955 /*
956 * Decide whether to use an indexscan or seqscan-and-optional-sort to scan
957 * the OldHeap. We know how to use a sort to duplicate the ordering of a
958 * btree index, and will use seqscan-and-sort for that case if the planner
959 * tells us it's cheaper. Otherwise, always indexscan if an index is
960 * provided, else plain seqscan.
961 */
965 else
967
968 /* Log what we're doing */
970 ereport(elevel,
972 nspname,
976 ereport(elevel,
978 nspname,
980 else
981 ereport(elevel,
983 nspname,
985
986 /*
987 * Hand off the actual copying to AM specific function, the generic code
988 * cannot know how to deal with visibility across AMs. Note that this
989 * routine is allowed to set FreezeXid / MultiXactCutoff to different
990 * values (e.g. because the AM doesn't use freezing).
991 */
993 cutoffs.OldestXmin, &cutoffs.FreezeLimit,
994 &cutoffs.MultiXactCutoff,
995 &num_tuples, &tups_vacuumed,
996 &tups_recently_dead);
997
998 /* return selected values to caller, get set as relfrozenxid/minmxid */
999 *pFreezeXid = cutoffs.FreezeLimit;
1000 *pCutoffMulti = cutoffs.MultiXactCutoff;
1001
1002 /* Reset rd_toastoid just to be tidy --- it shouldn't be looked at again */
1004
1006
1007 /* Log what we did */
1008 ereport(elevel,
1010 nspname,
1012 tups_vacuumed, num_tuples,
1015 "%s.",
1016 tups_recently_dead,
1018
1019 /* Update pg_class to reflect the correct values of pages and tuples. */
1021
1028
1029 relform->relpages = num_pages;
1030 relform->reltuples = num_tuples;
1031
1032 /* Don't update the stats for pg_class. See swap_relation_files. */
1035 else
1037
1038 /* Clean up. */
1041
1042 /* Make the update visible */
1043 CommandCounterIncrement();
1044}
void CatalogTupleUpdate(Relation heapRel, const ItemPointerData *otid, HeapTuple tup)
Definition indexing.c:313
void CacheInvalidateRelcacheByTuple(HeapTuple classTuple)
Definition inval.c:1669
bool MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2)
Definition multixact.c:2857
bool plan_cluster_use_sort(Oid tableOid, Oid indexOid)
Definition planner.c:6899
Definition htup.h:63
Definition pg_rusage.h:23
Definition tupdesc.h:149
Definition vacuum.h:258
Definition vacuum.h:217
static void table_relation_copy_for_cluster(Relation OldTable, Relation NewTable, Relation OldIndex, bool use_sort, TransactionId OldestXmin, TransactionId *xid_cutoff, MultiXactId *multi_cutoff, double *num_tuples, double *tups_vacuumed, double *tups_recently_dead)
Definition tableam.h:1668
static bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition transam.h:263
bool vacuum_get_cutoffs(Relation rel, const VacuumParams params, struct VacuumCutoffs *cutoffs)
Definition vacuum.c:1100
References AccessExclusiveLock, Assert, CacheInvalidateRelcacheByTuple(), CatalogTupleUpdate(), CommandCounterIncrement(), DEBUG2, elog, ereport, errdetail(), errmsg, ERROR, fb(), VacuumCutoffs::FreezeLimit, get_namespace_name(), GETSTRUCT(), heap_freetuple(), HeapTupleIsValid, INFO, InvalidOid, LockRelationOid(), VacuumCutoffs::MultiXactCutoff, MultiXactIdIsValid, MultiXactIdPrecedes(), ObjectIdGetDatum(), VacuumCutoffs::OldestXmin, pg_rusage_init(), pg_rusage_show(), PG_USED_FOR_ASSERTS_ONLY, plan_cluster_use_sort(), RelationGetDescr, RelationGetNamespace, RelationGetNumberOfBlocks, RelationGetRelationName, RelationGetRelid, VacuumCutoffs::relfrozenxid, VacuumCutoffs::relminmxid, RowExclusiveLock, SearchSysCacheCopy1, table_close(), table_open(), table_relation_copy_for_cluster(), TransactionIdIsValid, TransactionIdPrecedes(), vacuum_get_cutoffs(), and verbose.
Referenced by rebuild_relation().
◆ determine_clustered_index()
|
static |
Definition at line 1972 of file cluster.c.
1973{
1974 Oid indexOid;
1975
1977 {
1978 /*
1979 * If USING INDEX with no name is given, find a clustered index, or
1980 * error out if none.
1981 */
1982 indexOid = InvalidOid;
1984 {
1986 {
1987 indexOid = idxoid;
1988 break;
1989 }
1990 }
1991
1996 RelationGetRelationName(rel)));
1997 }
1999 {
2000 /* An index was specified; obtain its OID. */
2006 indexname, RelationGetRelationName(rel)));
2007 }
2008 else
2009 indexOid = InvalidOid;
2010
2011 return indexOid;
2012}
Oid get_relname_relid(const char *relname, Oid relnamespace)
Definition lsyscache.c:2105
References ereport, errcode(), errmsg, ERROR, fb(), foreach_oid, get_index_isclustered(), get_relname_relid(), InvalidOid, OidIsValid, RelationData::rd_rel, RelationGetIndexList(), and RelationGetRelationName.
Referenced by ExecRepack(), and process_single_relation().
◆ ExecRepack()
| void ExecRepack | ( | ParseState * | pstate, |
| RepackStmt * | stmt, | ||
| bool | isTopLevel | ||
| ) |
Definition at line 113 of file cluster.c.
114{
115 ClusterParams params = {0};
119
120 /* Parse option list */
122 {
128 else
133 opt->defname),
134 parser_errposition(pstate, opt->location));
135 }
136
137 /*
138 * If a single relation is specified, process it and we're done ... unless
139 * the relation is a partitioned table, in which case we fall through.
140 */
142 {
145 return; /* all done */
146 }
147
148 /*
149 * Don't allow ANALYZE in the multiple-relation case for now. Maybe we
150 * can add support for this later.
151 */
156 "REPACK (ANALYZE)"));
157
158 /*
159 * By here, we know we are in a multi-table situation. In order to avoid
160 * holding locks for too long, we want to process each table in its own
161 * transaction. This forces us to disallow running inside a user
162 * transaction block.
163 */
165
166 /* Also, we need a memory context to hold our list of relations */
168 "Repack",
169 ALLOCSET_DEFAULT_SIZES);
170
172
173 /*
174 * If we don't have a relation yet, determine a relation list. If we do,
175 * then it must be a partitioned table, and we want to process its
176 * partitions.
177 */
179 {
182 repack_context);
184 }
185 else
186 {
187 Oid relid;
189
191
192 /*
193 * If USING INDEX was specified, resolve the index name now and pass
194 * it down.
195 */
197 {
198 /*
199 * If no index name was specified when repacking a partitioned
200 * table, punt for now. Maybe we can improve this later.
201 */
203 {
208 RelationGetRelationName(rel)));
209 else
212 /*- translator: first %s is name of a SQL command, eg. REPACK */
215 RelationGetRelationName(rel)));
216 }
217
219 stmt->indexname);
223
225 }
226 else
227 {
228 relid = RelationGetRelid(rel);
230 }
231
233 relid, rel_is_index,
234 repack_context);
235
236 /* close parent relation, releasing lock on it */
238 rel = NULL;
239 }
240
241 /* Commit to get out of starting transaction */
242 PopActiveSnapshot();
243 CommitTransactionCommand();
244
245 /* Cluster the tables, each in a separate transaction */
248 {
249 /* Start a new transaction for each relation. */
250 StartTransactionCommand();
251
252 /*
253 * Open the target table, coping with the case where it has been
254 * dropped.
255 */
258 {
259 CommitTransactionCommand();
260 continue;
261 }
262
263 /* functions in indexes may want a snapshot set */
265
266 /* Process this table */
268 /* cluster_rel closes the relation, but keeps lock */
269
270 PopActiveSnapshot();
271 CommitTransactionCommand();
272 }
273
274 /* Start a new transaction for the cleanup work. */
275 StartTransactionCommand();
276
277 /* Clean up working storage */
279}
static Relation process_single_relation(RepackStmt *stmt, ClusterParams *params)
Definition cluster.c:1879
static List * get_tables_to_repack_partitioned(RepackCommand cmd, Oid relid, bool rel_is_index, MemoryContext permcxt)
Definition cluster.c:1788
static List * get_tables_to_repack(RepackCommand cmd, bool usingindex, MemoryContext permcxt)
Definition cluster.c:1658
void cluster_rel(RepackCommand cmd, Relation OldHeap, Oid indexOid, ClusterParams *params)
Definition cluster.c:300
static Oid determine_clustered_index(Relation rel, bool usingindex, const char *indexname)
Definition cluster.c:1972
int parser_errposition(ParseState *pstate, int location)
Definition parse_node.c:106
Definition cluster.h:30
Definition parsenodes.h:854
Definition pg_list.h:54
Definition memnodes.h:118
Definition cluster.c:64
void PreventInTransactionBlock(bool isTopLevel, const char *stmtType)
Definition xact.c:3670
References AccessExclusiveLock, ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, check_index_is_clusterable(), CLUOPT_ANALYZE, CLUOPT_RECHECK, CLUOPT_RECHECK_ISCLUSTERED, CLUOPT_VERBOSE, cluster_rel(), CommitTransactionCommand(), defGetBoolean(), determine_clustered_index(), elog, ereport, errcode(), errmsg, ERROR, fb(), foreach_node, foreach_ptr, get_tables_to_repack(), get_tables_to_repack_partitioned(), GetTransactionSnapshot(), MemoryContextDelete(), OidIsValid, ClusterParams::options, parser_errposition(), PopActiveSnapshot(), PortalContext, PreventInTransactionBlock(), process_single_relation(), PushActiveSnapshot(), RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, REPACK_COMMAND_CLUSTER, RepackCommandAsString(), StartTransactionCommand(), stmt, table_close(), and try_table_open().
Referenced by standard_ProcessUtility().
◆ finish_heap_swap()
| void finish_heap_swap | ( | Oid | OIDOldHeap, |
| Oid | OIDNewHeap, | ||
| bool | is_system_catalog, | ||
| bool | swap_toast_by_content, | ||
| bool | check_constraints, | ||
| bool | is_internal, | ||
| TransactionId | frozenXid, | ||
| MultiXactId | cutoffMulti, | ||
| char | newrelpersistence | ||
| ) |
Definition at line 1455 of file cluster.c.
1463{
1464 ObjectAddress object;
1469
1470 /* Report that we are now swapping relation files */
1473
1474 /* Zero out possible results from swapped_relation_files */
1476
1477 /*
1478 * Swap the contents of the heap relations (including any toast tables).
1479 * Also set old heap's relfrozenxid to frozenXid.
1480 */
1483 swap_toast_by_content, is_internal,
1485
1486 /*
1487 * If it's a system catalog, queue a sinval message to flush all catcaches
1488 * on the catalog when we reach CommandCounterIncrement.
1489 */
1492
1493 /*
1494 * Rebuild each index on the relation (but not the toast table, which is
1495 * all-new at this point). It is important to do this before the DROP
1496 * step because if we are processing a system catalog that will be used
1497 * during DROP, we want to have its indexes available. There is no
1498 * advantage to the other order anyway because this is all transactional,
1499 * so no chance to reclaim disk space before commit. We do not need a
1500 * final CommandCounterIncrement() because reindex_relation does it.
1501 *
1502 * Note: because index_build is called via reindex_relation, it will never
1503 * set indcheckxmin true for the indexes. This is OK even though in some
1504 * sense we are building new indexes rather than rebuilding existing ones,
1505 * because the new heap won't contain any HOT chains at all, let alone
1506 * broken ones, so it can't be necessary to set indcheckxmin.
1507 */
1511
1512 /*
1513 * Ensure that the indexes have the same persistence as the parent
1514 * relation.
1515 */
1520
1521 /* Report that we are now reindexing relations */
1524
1526
1527 /* Report that we are now doing clean up */
1530
1531 /*
1532 * If the relation being rebuilt is pg_class, swap_relation_files()
1533 * couldn't update pg_class's own pg_class entry (check comments in
1534 * swap_relation_files()), thus relfrozenxid was not updated. That's
1535 * annoying because a potential reason for doing a VACUUM FULL is a
1536 * imminent or actual anti-wraparound shutdown. So, now that we can
1537 * access the new relation using its indices, update relfrozenxid.
1538 * pg_class doesn't have a toast relation, so we don't need to update the
1539 * corresponding toast relation. Not that there's little point moving all
1540 * relfrozenxid updates here since swap_relation_files() needs to write to
1541 * pg_class for non-mapped relations anyway.
1542 */
1544 {
1548
1550
1555
1558
1560
1562 }
1563
1564 /* Destroy new heap with old filenumber */
1567 object.objectSubId = 0;
1568
1569 /*
1570 * The new relation is local to our transaction and we know nothing
1571 * depends on it, so DROP_RESTRICT should be OK.
1572 */
1574
1575 /* performDeletion does CommandCounterIncrement at end */
1576
1577 /*
1578 * Now we must remove any relation mapping entries that we set up for the
1579 * transient table, as well as its toast table and toast index if any. If
1580 * we fail to do this before commit, the relmapper will complain about new
1581 * permanent map entries being added post-bootstrap.
1582 */
1585
1586 /*
1587 * At this point, everything is kosher except that, if we did toast swap
1588 * by links, the toast table's name corresponds to the transient table.
1589 * The name is irrelevant to the backend because it's referenced by OID,
1590 * but users looking at the catalogs could be confused. Rename it to
1591 * prevent this problem.
1592 *
1593 * Note no lock required on the relation, because we already hold an
1594 * exclusive lock on it.
1595 */
1597 {
1599
1602 {
1605
1606 /* Get the associated valid index to be renamed */
1608 NoLock);
1609
1610 /* rename the toast table ... */
1612 OIDOldHeap);
1615
1616 /* ... and its valid index too. */
1618 OIDOldHeap);
1619
1622
1623 /*
1624 * Reset the relrewrite for the toast. The command-counter
1625 * increment is required here as we are about to update the tuple
1626 * that is updated as part of RenameRelationInternal.
1627 */
1628 CommandCounterIncrement();
1630 }
1632 }
1633
1634 /* if it's not a catalog table, clear any missing attribute settings */
1636 {
1638
1642 }
1643}
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:1073
void performDeletion(const ObjectAddress *object, DropBehavior behavior, int flags)
Definition dependency.c:279
bool reindex_relation(const ReindexStmt *stmt, Oid relid, int flags, const ReindexParams *params)
Definition index.c:3949
#define REINDEX_REL_FORCE_INDEXES_PERMANENT
Definition index.h:169
#define PROGRESS_REPACK_PHASE_SWAP_REL_FILES
Definition progress.h:101
#define PROGRESS_REPACK_PHASE_FINAL_CLEANUP
Definition progress.h:103
#define PROGRESS_REPACK_PHASE_REBUILD_INDEX
Definition progress.h:102
Definition objectaddress.h:26
Definition index.h:40
void RenameRelationInternal(Oid myrelid, const char *newrelname, bool is_internal, bool is_index)
Definition tablecmds.c:4301
Oid toast_get_valid_index(Oid toastoid, LOCKMODE lock)
Definition toast_internals.c:519
References CacheInvalidateCatalog(), CatalogTupleUpdate(), CommandCounterIncrement(), DROP_RESTRICT, elog, ERROR, fb(), GETSTRUCT(), HeapTupleIsValid, i, NAMEDATALEN, NoLock, ObjectIdGetDatum(), OidIsValid, PERFORM_DELETION_INTERNAL, performDeletion(), pgstat_progress_update_param(), PROGRESS_REPACK_PHASE, PROGRESS_REPACK_PHASE_FINAL_CLEANUP, PROGRESS_REPACK_PHASE_REBUILD_INDEX, PROGRESS_REPACK_PHASE_SWAP_REL_FILES, REINDEX_REL_CHECK_CONSTRAINTS, REINDEX_REL_FORCE_INDEXES_PERMANENT, REINDEX_REL_FORCE_INDEXES_UNLOGGED, REINDEX_REL_SUPPRESS_INDEX_USE, reindex_relation(), relation_close(), RelationClearMissing(), RelationMapRemoveMapping(), RenameRelationInternal(), ResetRelRewrite(), RowExclusiveLock, SearchSysCacheCopy1, snprintf, swap_relation_files(), table_close(), table_open(), and toast_get_valid_index().
Referenced by ATRewriteTables(), rebuild_relation(), and refresh_by_heap_swap().
◆ get_tables_to_repack()
|
static |
Definition at line 1658 of file cluster.c.
1659{
1661 TableScanDesc scan;
1662 HeapTuple tuple;
1664
1665 if (usingindex)
1666 {
1667 ScanKeyData entry;
1668
1669 /*
1670 * For USING INDEX, scan pg_index to find those with indisclustered.
1671 */
1673 ScanKeyInit(&entry,
1679 {
1683
1685
1686 /*
1687 * Try to obtain a light lock on the index's table, to ensure it
1688 * doesn't go away while we collect the list. If we cannot, just
1689 * disregard it. Be sure to release this if we ultimately decide
1690 * not to process the table!
1691 */
1693 continue;
1694
1695 /* Verify that the table still exists; skip if not */
1697 {
1699 continue;
1700 }
1701
1702 /* noisily skip rels which the user can't process */
1704 GetUserId()))
1705 {
1707 continue;
1708 }
1709
1710 /* Use a permanent memory context for the result list */
1717 }
1718 }
1719 else
1720 {
1723
1725 {
1729
1731
1732 /*
1733 * Try to obtain a light lock on the table, to ensure it doesn't
1734 * go away while we collect the list. If we cannot, just
1735 * disregard the table. Be sure to release this if we ultimately
1736 * decide not to process the table!
1737 */
1739 continue;
1740
1741 /* Verify that the table still exists */
1743 {
1745 continue;
1746 }
1747
1748 /* Can only process plain tables and matviews */
1751 {
1753 continue;
1754 }
1755
1756 /* noisily skip rels which the user can't process */
1758 GetUserId()))
1759 {
1761 continue;
1762 }
1763
1764 /* Use a permanent memory context for the result list */
1771 }
1772 }
1773
1774 table_endscan(scan);
1776
1778}
HeapTuple heap_getnext(TableScanDesc sscan, ScanDirection direction)
Definition heapam.c:1420
bool ConditionalLockRelationOid(Oid relid, LOCKMODE lockmode)
Definition lmgr.c:151
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition palloc.h:124
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
Definition scankey.c:76
Definition skey.h:65
Definition relscan.h:33
TableScanDesc table_beginscan_catalog(Relation relation, int nkeys, ScanKeyData *key)
Definition tableam.c:113
References AccessShareLock, BoolGetDatum(), BTEqualStrategyNumber, ConditionalLockRelationOid(), fb(), Form_pg_index, ForwardScanDirection, GETSTRUCT(), GetUserId(), heap_getnext(), InvalidOid, lappend(), MemoryContextSwitchTo(), NIL, ObjectIdGetDatum(), palloc_object, relation_close(), repack_is_permitted_for_relation(), ScanKeyInit(), SearchSysCacheExists1, table_beginscan_catalog(), table_endscan(), table_open(), and UnlockRelationOid().
Referenced by ExecRepack().
◆ get_tables_to_repack_partitioned()
|
static |
Definition at line 1788 of file cluster.c.
1790{
1793
1794 /*
1795 * Do not lock the children until they're processed. Note that we do hold
1796 * a lock on the parent partitioned table.
1797 */
1800 {
1802 index_oid;
1805
1807 {
1808 /* consider only leaf indexes */
1810 continue;
1811
1814 }
1815 else
1816 {
1817 /* consider only leaf relations */
1819 continue;
1820
1823 }
1824
1825 /*
1826 * It's possible that the user does not have privileges to CLUSTER the
1827 * leaf partition despite having them on the partitioned table. Skip
1828 * if so.
1829 */
1831 continue;
1832
1833 /* Use a permanent memory context for the result list */
1840 }
1841
1843}
List * find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, List **numparents)
Definition pg_inherits.c:256
References fb(), find_all_inheritors(), foreach_oid, get_rel_relkind(), GetUserId(), IndexGetRelation(), InvalidOid, lappend(), MemoryContextSwitchTo(), NIL, NoLock, palloc_object, and repack_is_permitted_for_relation().
Referenced by ExecRepack().
◆ make_new_heap()
| Oid make_new_heap | ( | Oid | OIDOldHeap, |
| Oid | NewTableSpace, | ||
| Oid | NewAccessMethod, | ||
| char | relpersistence, | ||
| LOCKMODE | lockmode | ||
| ) |
Definition at line 715 of file cluster.c.
717{
723 HeapTuple tuple;
724 Datum reloptions;
725 bool isNull;
727
730
731 /*
732 * Note that the NewHeap will not receive any of the defaults or
733 * constraints associated with the OldHeap; we don't need 'em, and there's
734 * no reason to spend cycles inserting them into the catalogs only to
735 * delete them.
736 */
737
738 /*
739 * But we do want to use reloptions of the old heap for new heap.
740 */
745 &isNull);
746 if (isNull)
747 reloptions = (Datum) 0;
748
751 else
753
754 /*
755 * Create the new heap, using a temporary name in the same namespace as
756 * the existing table. NOTE: there is some risk of collision with user
757 * relnames. Working around this seems more trouble than it's worth; in
758 * particular, we can't create the new heap in a different namespace from
759 * the old, or we will have problems with the TEMP status of temp tables.
760 *
761 * Note: the new heap is not a shared relation, even if we are rebuilding
762 * a shared rel. However, we do make the new heap mapped if the source is
763 * mapped. This simplifies swap_relation_files, and is absolutely
764 * necessary for rebuilding pg_class, for reasons explained there.
765 */
767
769 namespaceid,
770 NewTableSpace,
771 InvalidOid,
772 InvalidOid,
773 InvalidOid,
774 OldHeap->rd_rel->relowner,
775 NewAccessMethod,
776 OldHeapDesc,
777 NIL,
778 RELKIND_RELATION,
779 relpersistence,
780 false,
782 ONCOMMIT_NOOP,
783 reloptions,
784 false,
785 true,
786 true,
787 OIDOldHeap,
788 NULL);
790
791 ReleaseSysCache(tuple);
792
793 /*
794 * Advance command counter so that the newly-created relation's catalog
795 * tuples will be visible to table_open.
796 */
797 CommandCounterIncrement();
798
799 /*
800 * If necessary, create a TOAST table for the new relation.
801 *
802 * If the relation doesn't have a TOAST table already, we can't need one
803 * for the new relation. The other way around is possible though: if some
804 * wide columns have been dropped, NewHeapCreateToastTable can decide that
805 * no TOAST table is needed for the new table.
806 *
807 * Note that NewHeapCreateToastTable ends with CommandCounterIncrement, so
808 * that the TOAST table will be visible for insertion.
809 */
812 {
813 /* keep the existing toast table's reloptions, if any */
818 &isNull);
819 if (isNull)
820 reloptions = (Datum) 0;
821
823
824 ReleaseSysCache(tuple);
825 }
826
828
830}
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:1122
HeapTuple SearchSysCache1(SysCacheIdentifier cacheId, Datum key1)
Definition syscache.c:221
Datum SysCacheGetAttr(SysCacheIdentifier cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Definition syscache.c:596
void NewHeapCreateToastTable(Oid relOid, Datum reloptions, LOCKMODE lockmode, Oid OIDOldToast)
Definition toasting.c:64
References Assert, CommandCounterIncrement(), elog, ERROR, fb(), heap_create_with_catalog(), HeapTupleIsValid, InvalidOid, LookupCreationNamespace(), NAMEDATALEN, NewHeapCreateToastTable(), NIL, NoLock, ObjectIdGetDatum(), OidIsValid, ONCOMMIT_NOOP, RelationGetDescr, RelationGetNamespace, RelationIsMapped, ReleaseSysCache(), SearchSysCache1(), snprintf, SysCacheGetAttr(), table_close(), and table_open().
Referenced by ATRewriteTables(), rebuild_relation(), and RefreshMatViewByOid().
◆ mark_index_clustered()
Definition at line 568 of file cluster.c.
569{
574
576
577 /*
578 * If the index is already marked clustered, no need to do anything.
579 */
581 {
583 return;
584 }
585
586 /*
587 * Check each index of the relation and set/clear the bit as needed.
588 */
590
592 {
594
600
601 /*
602 * Unset the bit if set. We know it's wrong because we checked this
603 * earlier.
604 */
606 {
609 }
611 {
612 /* this was checked earlier, but let's be real sure */
617 }
618
620 InvalidOid, is_internal);
621
623 }
624
626}
#define InvokeObjectPostAlterHookArg(classId, objectId, subId, auxiliaryId, is_internal)
Definition objectaccess.h:200
Definition pg_list.h:46
References Assert, CatalogTupleUpdate(), elog, ERROR, fb(), Form_pg_index, get_index_isclustered(), GETSTRUCT(), heap_freetuple(), HeapTupleIsValid, InvalidOid, InvokeObjectPostAlterHookArg, lfirst_oid, ObjectIdGetDatum(), OidIsValid, RelationData::rd_rel, RelationGetIndexList(), RowExclusiveLock, SearchSysCacheCopy1, table_close(), and table_open().
Referenced by ATExecClusterOn(), ATExecDropCluster(), and rebuild_relation().
◆ process_single_relation()
|
static |
Definition at line 1879 of file cluster.c.
1880{
1881 Relation rel;
1882 Oid tableOid;
1883
1887
1888 /*
1889 * Make sure ANALYZE is specified if a column list is present.
1890 */
1895
1896 /*
1897 * Find, lock, and check permissions on the table. We obtain
1898 * AccessExclusiveLock right away to avoid lock-upgrade hazard in the
1899 * single-transaction case.
1900 */
1902 AccessExclusiveLock,
1903 0,
1905 NULL);
1907
1908 /*
1909 * Reject clustering a remote temp table ... their local buffer manager is
1910 * not going to cope.
1911 */
1915 /*- translator: first %s is name of a SQL command, eg. REPACK */
1918
1919 /*
1920 * For partitioned tables, let caller handle this. Otherwise, process it
1921 * here and we're done.
1922 */
1924 return rel;
1925 else
1926 {
1927 Oid indexOid;
1928
1930 stmt->indexname);
1934
1935 /*
1936 * Do an analyze, if requested. We close the transaction and start a
1937 * new one, so that we don't hold the stronger lock for longer than
1938 * needed.
1939 */
1941 {
1943
1944 PopActiveSnapshot();
1945 CommitTransactionCommand();
1946
1947 StartTransactionCommand();
1949
1955 PopActiveSnapshot();
1956 CommandCounterIncrement();
1957 }
1958
1960 }
1961}
void analyze_rel(Oid relid, RangeVar *relation, const VacuumParams params, List *va_cols, bool in_outer_xact, BufferAccessStrategy bstrategy)
Definition analyze.c:109
Oid RangeVarGetRelidExtended(const RangeVar *relation, LOCKMODE lockmode, uint32 flags, RangeVarGetRelidCallback callback, void *callback_arg)
Definition namespace.c:442
void RangeVarCallbackMaintainsTable(const RangeVar *relation, Oid relId, Oid oldRelId, void *arg)
Definition tablecmds.c:19728
References AccessExclusiveLock, analyze_rel(), Assert, check_index_is_clusterable(), CLUOPT_ANALYZE, CLUOPT_VERBOSE, cluster_rel(), CommandCounterIncrement(), CommitTransactionCommand(), determine_clustered_index(), ereport, errcode(), errmsg, ERROR, fb(), GetTransactionSnapshot(), NIL, NoLock, OidIsValid, ClusterParams::options, PopActiveSnapshot(), PushActiveSnapshot(), RangeVarCallbackMaintainsTable(), RangeVarGetRelidExtended(), RelationData::rd_rel, RELATION_IS_OTHER_TEMP, REPACK_COMMAND_CLUSTER, REPACK_COMMAND_REPACK, RepackCommandAsString(), StartTransactionCommand(), stmt, table_open(), VACOPT_ANALYZE, and VACOPT_VERBOSE.
Referenced by ExecRepack().
◆ rebuild_relation()
Definition at line 639 of file cluster.c.
640{
646 char relpersistence;
651
654
655 /* for CLUSTER or REPACK USING INDEX, mark the index as the one to use */
658
659 /* Remember info about rel before closing OldHeap */
660 relpersistence = OldHeap->rd_rel->relpersistence;
662
663 /*
664 * Create the transient table that will receive the re-ordered data.
665 *
666 * OldHeap is already locked, so no need to lock it again. make_new_heap
667 * obtains AccessExclusiveLock on the new heap and its toast table.
668 */
670 accessMethod,
671 relpersistence,
672 NoLock);
675
676 /* Copy the heap data into the new table in the desired order */
679
680
681 /* Close relcache entries, but keep lock until transaction commit */
685
686 /*
687 * Close the new relation so it can be dropped as soon as the storage is
688 * swapped. The relation is not visible to others, so no need to unlock it
689 * explicitly.
690 */
692
693 /*
694 * Swap the physical files of the target and transient tables, then
695 * rebuild the target's indexes and throw away the transient table.
696 */
700 relpersistence);
701}
static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex, bool verbose, bool *pSwapToastByContent, TransactionId *pFreezeXid, MultiXactId *pCutoffMulti)
Definition cluster.c:841
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 cluster.c:1455
Oid make_new_heap(Oid OIDOldHeap, Oid NewTableSpace, Oid NewAccessMethod, char relpersistence, LOCKMODE lockmode)
Definition cluster.c:715
void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal)
Definition cluster.c:568
bool CheckRelationOidLockedByMe(Oid relid, LOCKMODE lockmode, bool orstronger)
Definition lmgr.c:351
References AccessExclusiveLock, Assert, CheckRelationLockedByMe(), CheckRelationOidLockedByMe(), copy_table_data(), fb(), finish_heap_swap(), index_close(), IsSystemRelation(), make_new_heap(), mark_index_clustered(), NoLock, RelationGetRelid, table_close(), table_open(), and verbose.
Referenced by cluster_rel().
◆ repack_is_permitted_for_relation()
|
static |
Definition at line 1851 of file cluster.c.
1852{
1854
1856 return true;
1857
1860 RepackCommandAsString(cmd),
1861 get_rel_name(relid)));
1862
1863 return false;
1864}
AclResult pg_class_aclcheck(Oid table_oid, Oid roleid, AclMode mode)
Definition aclchk.c:4082
References ACL_MAINTAIN, ACLCHECK_OK, Assert, ereport, errmsg, get_rel_name(), pg_class_aclcheck(), REPACK_COMMAND_CLUSTER, REPACK_COMMAND_REPACK, RepackCommandAsString(), and WARNING.
Referenced by cluster_rel_recheck(), get_tables_to_repack(), and get_tables_to_repack_partitioned().
◆ RepackCommandAsString()
|
static |
Definition at line 2015 of file cluster.c.
2016{
2017 switch (cmd)
2018 {
2020 return "REPACK";
2022 return "VACUUM";
2024 return "CLUSTER";
2025 }
2026 return "???"; /* keep compiler quiet */
2027}
References REPACK_COMMAND_CLUSTER, REPACK_COMMAND_REPACK, and REPACK_COMMAND_VACUUMFULL.
Referenced by cluster_rel(), ExecRepack(), process_single_relation(), and repack_is_permitted_for_relation().
◆ swap_relation_files()
|
static |
Definition at line 1073 of file cluster.c.
1079{
1082 reltup2;
1084 relform2;
1086 relfilenumber2;
1090 relam2;
1091
1092 /* We need writable copies of both pg_class tuples. */
1094
1099
1104
1109
1112 {
1113 /*
1114 * Normal non-mapped relations: swap relfilenumbers, reltablespaces,
1115 * relpersistence
1116 */
1118
1122
1126
1130
1134
1135 /* Also swap toast links, if we're swapping by links */
1137 {
1141 }
1142 }
1143 else
1144 {
1145 /*
1146 * Mapped-relation case. Here we have to swap the relation mappings
1147 * instead of modifying the pg_class columns. Both must be mapped.
1148 */
1153
1154 /*
1155 * We can't change the tablespace nor persistence of a mapped rel, and
1156 * we can't handle toast link swapping for one either, because we must
1157 * not apply any critical changes to its pg_class row. These cases
1158 * should be prevented by upstream permissions tests, so these checks
1159 * are non-user-facing emergency backstop.
1160 */
1174
1175 /*
1176 * Fetch the mappings --- shouldn't fail, but be paranoid
1177 */
1186
1187 /*
1188 * Send replacement mappings to relmapper. Note these won't actually
1189 * take effect until CommandCounterIncrement.
1190 */
1193
1194 /* Pass OIDs of mapped r2 tables back to caller */
1196 }
1197
1198 /*
1199 * Recognize that rel1's relfilenumber (swapped from rel2) is new in this
1200 * subtransaction. The rel2 storage (swapped from rel1) may or may not be
1201 * new.
1202 */
1203 {
1205 rel2;
1206
1215 }
1216
1217 /*
1218 * In the case of a shared catalog, these next few steps will only affect
1219 * our own database's pg_class row; but that's okay, because they are all
1220 * noncritical updates. That's also an important fact for the case of a
1221 * mapped catalog, because it's possible that we'll commit the map change
1222 * and then fail to commit the pg_class update.
1223 */
1224
1225 /* set rel1's frozen Xid and minimum MultiXid */
1227 {
1232 }
1233
1234 /* swap size statistics too, since new rel has freshly-updated stats */
1235 {
1240
1244
1248
1252
1256 }
1257
1258 /*
1259 * Update the tuples in pg_class --- unless the target relation of the
1260 * swap is pg_class itself. In that case, there is zero point in making
1261 * changes because we'd be updating the old data that we're about to throw
1262 * away. Because the real work being done here for a mapped relation is
1263 * just to change the relation map settings, it's all right to not update
1264 * the pg_class rows in this case. The most important changes will instead
1265 * performed later, in finish_heap_swap() itself.
1266 */
1268 {
1270
1273 indstate);
1275 indstate);
1277 }
1278 else
1279 {
1280 /* no update ... but we do still need relcache inval */
1283 }
1284
1285 /*
1286 * Now that pg_class has been updated with its relevant information for
1287 * the swap, update the dependency of the relations to point to their new
1288 * table AM, if it has changed.
1289 */
1291 {
1293 r1,
1294 AccessMethodRelationId,
1295 relam1,
1296 relam2) != 1)
1301 r2,
1302 AccessMethodRelationId,
1303 relam2,
1304 relam1) != 1)
1308 }
1309
1310 /*
1311 * Post alter hook for modified relations. The change to r2 is always
1312 * internal, but r1 depends on the invocation context.
1313 */
1315 InvalidOid, is_internal);
1318
1319 /*
1320 * If we have toast tables associated with the relations being swapped,
1321 * deal with them too.
1322 */
1324 {
1326 {
1328 {
1329 /* Recursively swap the contents of the toast tables */
1331 relform2->reltoastrelid,
1332 target_is_pg_class,
1333 swap_toast_by_content,
1334 is_internal,
1335 frozenXid,
1336 cutoffMulti,
1337 mapped_tables);
1338 }
1339 else
1340 {
1341 /* caller messed up */
1343 }
1344 }
1345 else
1346 {
1347 /*
1348 * We swapped the ownership links, so we need to change dependency
1349 * data to match.
1350 *
1351 * NOTE: it is possible that only one table has a toast table.
1352 *
1353 * NOTE: at present, a TOAST table's only dependency is the one on
1354 * its owning table. If more are ever created, we'd need to use
1355 * something more selective than deleteDependencyRecordsFor() to
1356 * get rid of just the link we want.
1357 */
1359 toastobject;
1360 long count;
1361
1362 /*
1363 * We disallow this case for system catalogs, to avoid the
1364 * possibility that the catalog we're rebuilding is one of the
1365 * ones the dependency changes would change. It's too late to be
1366 * making any data changes to the target catalog.
1367 */
1370
1371 /* Delete old dependencies */
1373 {
1375 relform1->reltoastrelid,
1376 false);
1377 if (count != 1)
1379 count);
1380 }
1382 {
1384 relform2->reltoastrelid,
1385 false);
1386 if (count != 1)
1388 count);
1389 }
1390
1391 /* Register new dependencies */
1393 baseobject.objectSubId = 0;
1395 toastobject.objectSubId = 0;
1396
1398 {
1402 DEPENDENCY_INTERNAL);
1403 }
1404
1406 {
1410 DEPENDENCY_INTERNAL);
1411 }
1412 }
1413 }
1414
1415 /*
1416 * If we're swapping two toast tables by content, do the same for their
1417 * valid index. The swap can actually be safely done only if the relations
1418 * have indexes.
1419 */
1423 {
1425 toastIndex2;
1426
1427 /* Get valid index for each relation */
1429 AccessExclusiveLock);
1431 AccessExclusiveLock);
1432
1434 toastIndex2,
1435 target_is_pg_class,
1436 swap_toast_by_content,
1437 is_internal,
1438 InvalidTransactionId,
1439 InvalidMultiXactId,
1440 mapped_tables);
1441 }
1442
1443 /* Clean up. */
1446
1448}
void CatalogTupleUpdateWithInfo(Relation heapRel, const ItemPointerData *otid, HeapTuple tup, CatalogIndexState indstate)
Definition indexing.c:337
void recordDependencyOn(const ObjectAddress *depender, const ObjectAddress *referenced, DependencyType behavior)
Definition pg_depend.c:47
long changeDependencyFor(Oid classId, Oid objectId, Oid refClassId, Oid oldRefObjectId, Oid newRefObjectId)
Definition pg_depend.c:459
long deleteDependencyRecordsFor(Oid classId, Oid objectId, bool skipExtensionDeps)
Definition pg_depend.c:303
void RelationAssumeNewRelfilelocator(Relation relation)
Definition relcache.c:3968
RelFileNumber RelationMapOidToFilenumber(Oid relationId, bool shared)
Definition relmapper.c:166
void RelationMapUpdateMap(Oid relationId, RelFileNumber fileNumber, bool shared, bool immediate)
Definition relmapper.c:326
Definition execnodes.h:485
References AccessExclusiveLock, Assert, CacheInvalidateRelcacheByTuple(), CatalogCloseIndexes(), CatalogOpenIndexes(), CatalogTupleUpdateWithInfo(), changeDependencyFor(), deleteDependencyRecordsFor(), DEPENDENCY_INTERNAL, elog, ERROR, fb(), get_namespace_name(), get_rel_name(), get_rel_namespace(), GETSTRUCT(), heap_freetuple(), HeapTupleIsValid, InvalidMultiXactId, InvalidOid, InvalidTransactionId, InvokeObjectPostAlterHookArg, IsSystemClass(), NameStr, NoLock, ObjectIdGetDatum(), recordDependencyOn(), relation_close(), relation_open(), RelationAssumeNewRelfilelocator(), RelationMapOidToFilenumber(), RelationMapUpdateMap(), RelFileNumberIsValid, RowExclusiveLock, SearchSysCacheCopy1, swap_relation_files(), table_close(), table_open(), toast_get_valid_index(), TransactionIdIsNormal, and TransactionIdIsValid.
Referenced by finish_heap_swap(), and swap_relation_files().
