From: Bruce Momjian Date: Thu, 7 Oct 2004 14:19:58 +0000 (+0000) Subject: Back out unindented modification to file. X-Git-Tag: REL9_0_0~11707 X-Git-Url: http://git.osdn.net/view?a=commitdiff_plain;h=9da50e1f53f47671f571d75725a093af30bf0623;p=pg-rex%2Fsyncrep.git Back out unindented modification to file. --- diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c index 7390560d07..232ec9a89e 100644 --- a/src/backend/commands/vacuum.c +++ b/src/backend/commands/vacuum.c @@ -13,7 +13,7 @@ * * * IDENTIFICATION - * $PostgreSQL: pgsql/src/backend/commands/vacuum.c,v 1.293 2004/10/07 14:15:50 momjian Exp $ + * $PostgreSQL: pgsql/src/backend/commands/vacuum.c,v 1.294 2004/10/07 14:19:58 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -240,27 +240,20 @@ vacuum(VacuumStmt *vacstmt) if (vacstmt->verbose) elevel = INFO; else - /* bjm comment */ elevel = DEBUG2; - if (1 == 0) - func(); - else - /* bjm comment */ - { - elevel = DEBUG2; - } /* - * We cannot run VACUUM inside a user transaction block; if we were inside - * a transaction, then our commit- and start-transaction-command calls - * would not have the intended effect! Furthermore, the forced commit that - * occurs before truncating the relation's file would have the effect of - * committing the rest of the user's transaction too, which would - * certainly not be the desired behavior. (This only applies to VACUUM - * FULL, though. We could in theory run lazy VACUUM inside a transaction - * block, but we choose to disallow that case because we'd rather commit - * as soon as possible after finishing the vacuum. This is mainly so - * that we can let go the AccessExclusiveLock that we may be holding.) + * We cannot run VACUUM inside a user transaction block; if we were + * inside a transaction, then our commit- and + * start-transaction-command calls would not have the intended effect! + * Furthermore, the forced commit that occurs before truncating the + * relation's file would have the effect of committing the rest of the + * user's transaction too, which would certainly not be the desired + * behavior. (This only applies to VACUUM FULL, though. We could in + * theory run lazy VACUUM inside a transaction block, but we choose to + * disallow that case because we'd rather commit as soon as possible + * after finishing the vacuum. This is mainly so that we can let go + * the AccessExclusiveLock that we may be holding.) * * ANALYZE (without VACUUM) can run either way. */ @@ -272,15 +265,18 @@ vacuum(VacuumStmt *vacstmt) else in_outer_xact = IsInTransactionChain((void *) vacstmt); - /* Send info about dead objects to the statistics collector */ + /* + * Send info about dead objects to the statistics collector + */ if (vacstmt->vacuum) pgstat_vacuum_tabstat(); /* * Create special memory context for cross-transaction storage. * - * Since it is a child of PortalContext, it will go away eventually even if - * we suffer an error; there's no need for special abort cleanup logic. + * Since it is a child of PortalContext, it will go away eventually even + * if we suffer an error; there's no need for special abort cleanup + * logic. */ vac_context = AllocSetContextCreate(PortalContext, "Vacuum", @@ -299,21 +295,21 @@ vacuum(VacuumStmt *vacstmt) /* * It's a database-wide VACUUM. * - * Compute the initially applicable OldestXmin and FreezeLimit XIDs, so - * that we can record these values at the end of the VACUUM. Note that - * individual tables may well be processed with newer values, but we - * can guarantee that no (non-shared) relations are processed with - * older ones. + * Compute the initially applicable OldestXmin and FreezeLimit XIDs, + * so that we can record these values at the end of the VACUUM. + * Note that individual tables may well be processed with newer + * values, but we can guarantee that no (non-shared) relations are + * processed with older ones. * - * It is okay to record non-shared values in pg_database, even though we - * may vacuum shared relations with older cutoffs, because only the - * minimum of the values present in pg_database matters. We can be - * sure that shared relations have at some time been vacuumed with - * cutoffs no worse than the global minimum; for, if there is a - * backend in some other DB with xmin = OLDXMIN that's determining the - * cutoff with which we vacuum shared relations, it is not possible - * for that database to have a cutoff newer than OLDXMIN recorded in - * pg_database. + * It is okay to record non-shared values in pg_database, even though + * we may vacuum shared relations with older cutoffs, because only + * the minimum of the values present in pg_database matters. We + * can be sure that shared relations have at some time been + * vacuumed with cutoffs no worse than the global minimum; for, if + * there is a backend in some other DB with xmin = OLDXMIN that's + * determining the cutoff with which we vacuum shared relations, + * it is not possible for that database to have a cutoff newer + * than OLDXMIN recorded in pg_database. */ vacuum_set_xid_limits(vacstmt, false, &initialOldestXmin, @@ -323,15 +319,16 @@ vacuum(VacuumStmt *vacstmt) /* * Decide whether we need to start/commit our own transactions. * - * For VACUUM (with or without ANALYZE): always do so, so that we can release - * locks as soon as possible. (We could possibly use the outer - * transaction for a one-table VACUUM, but handling TOAST tables would be - * problematic.) + * For VACUUM (with or without ANALYZE): always do so, so that we can + * release locks as soon as possible. (We could possibly use the + * outer transaction for a one-table VACUUM, but handling TOAST tables + * would be problematic.) * * For ANALYZE (no VACUUM): if inside a transaction block, we cannot - * start/commit our own transactions. Also, there's no need to do so if - * only processing one relation. For multiple relations when not within a - * transaction block, use own transactions so we can release locks sooner. + * start/commit our own transactions. Also, there's no need to do so + * if only processing one relation. For multiple relations when not + * within a transaction block, use own transactions so we can release + * locks sooner. */ if (vacstmt->vacuum) use_own_xacts = true; @@ -347,8 +344,8 @@ vacuum(VacuumStmt *vacstmt) } /* - * If we are running ANALYZE without per-table transactions, we'll need a - * memory context with table lifetime. + * If we are running ANALYZE without per-table transactions, we'll + * need a memory context with table lifetime. */ if (!use_own_xacts) anl_context = AllocSetContextCreate(PortalContext, @@ -358,12 +355,12 @@ vacuum(VacuumStmt *vacstmt) ALLOCSET_DEFAULT_MAXSIZE); /* - * vacuum_rel expects to be entered with no transaction active; it will - * start and commit its own transaction. But we are called by an SQL - * command, and so we are executing inside a transaction already. We - * commit the transaction started in PostgresMain() here, and start - * another one before exiting to match the commit waiting for us back in - * PostgresMain(). + * vacuum_rel expects to be entered with no transaction active; it + * will start and commit its own transaction. But we are called by an + * SQL command, and so we are executing inside a transaction already. + * We commit the transaction started in PostgresMain() here, and start + * another one before exiting to match the commit waiting for us back + * in PostgresMain(). */ if (use_own_xacts) { @@ -379,7 +376,9 @@ vacuum(VacuumStmt *vacstmt) VacuumCostActive = (VacuumCostDelay > 0); VacuumCostBalance = 0; - /* Loop to process each selected relation. */ + /* + * Loop to process each selected relation. + */ foreach(cur, relations) { Oid relid = lfirst_oid(cur); @@ -394,11 +393,11 @@ vacuum(VacuumStmt *vacstmt) MemoryContext old_context = NULL; /* - * If using separate xacts, start one for analyze. Otherwise, - * we can use the outer transaction, but we still need to call - * analyze_rel in a memory context that will be cleaned up on - * return (else we leak memory while processing multiple - * tables). + * If using separate xacts, start one for analyze. + * Otherwise, we can use the outer transaction, but we + * still need to call analyze_rel in a memory context that + * will be cleaned up on return (else we leak memory while + * processing multiple tables). */ if (use_own_xacts) { @@ -410,8 +409,8 @@ vacuum(VacuumStmt *vacstmt) old_context = MemoryContextSwitchTo(anl_context); /* - * Tell the buffer replacement strategy that vacuum is causing - * the IO + * Tell the buffer replacement strategy that vacuum is + * causing the IO */ StrategyHintVacuum(true); @@ -440,7 +439,9 @@ vacuum(VacuumStmt *vacstmt) /* Turn off vacuum cost accounting */ VacuumCostActive = false; - /* Finish up processing. */ + /* + * Finish up processing. + */ if (use_own_xacts) { /* here, we are not in a transaction */ @@ -455,16 +456,16 @@ vacuum(VacuumStmt *vacstmt) if (vacstmt->vacuum) { /* - * If it was a database-wide VACUUM, print FSM usage statistics (we - * don't make you be superuser to see these). + * If it was a database-wide VACUUM, print FSM usage statistics + * (we don't make you be superuser to see these). */ if (vacstmt->relation == NULL) PrintFreeSpaceMapStatistics(elevel); /* * If we completed a database-wide VACUUM without skipping any - * relations, update the database's pg_database row with info about - * the transaction IDs used, and try to truncate pg_clog. + * relations, update the database's pg_database row with info + * about the transaction IDs used, and try to truncate pg_clog. */ if (all_rels) { @@ -476,8 +477,8 @@ vacuum(VacuumStmt *vacstmt) /* * Clean up working storage --- note we must do this after - * StartTransactionCommand, else we might be trying to delete the active - * context! + * StartTransactionCommand, else we might be trying to delete the + * active context! */ MemoryContextDelete(vac_context); vac_context = NULL; @@ -570,11 +571,15 @@ vacuum_set_xid_limits(VacuumStmt *vacstmt, bool sharedRel, limit = GetCurrentTransactionId() - (MaxTransactionId >> 2); } - /* Be careful not to generate a "permanent" XID */ + /* + * Be careful not to generate a "permanent" XID + */ if (!TransactionIdIsNormal(limit)) limit = FirstNormalTransactionId; - /* Ensure sane relationship of limits */ + /* + * Ensure sane relationship of limits + */ if (TransactionIdFollows(limit, *oldestXmin)) { ereport(WARNING, @@ -616,7 +621,9 @@ vac_update_relstats(Oid relid, BlockNumber num_pages, double num_tuples, Form_pg_class pgcform; Buffer buffer; - /* update number of tuples and number of pages in pg_class */ + /* + * update number of tuples and number of pages in pg_class + */ rd = heap_openr(RelationRelationName, RowExclusiveLock); ctup = SearchSysCache(RELOID, @@ -652,10 +659,10 @@ vac_update_relstats(Oid relid, BlockNumber num_pages, double num_tuples, LockBuffer(buffer, BUFFER_LOCK_UNLOCK); /* - * Invalidate the tuple in the catcaches; this also arranges to flush the - * relation's relcache entry. (If we fail to commit for some reason, no - * flush will occur, but no great harm is done since there are no - * noncritical state updates here.) + * Invalidate the tuple in the catcaches; this also arranges to flush + * the relation's relcache entry. (If we fail to commit for some + * reason, no flush will occur, but no great harm is done since there + * are no noncritical state updates here.) */ CacheInvalidateHeapTuple(rd, &rtup); @@ -788,8 +795,8 @@ vac_truncate_clog(TransactionId vacuumXID, TransactionId frozenXID) heap_close(relation, AccessShareLock); /* - * Do not truncate CLOG if we seem to have suffered wraparound already; - * the computed minimum XID might be bogus. + * Do not truncate CLOG if we seem to have suffered wraparound + * already; the computed minimum XID might be bogus. */ if (vacuumAlreadyWrapped) { @@ -874,8 +881,8 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt, char expected_relkind) CHECK_FOR_INTERRUPTS(); /* - * Race condition -- if the pg_class tuple has gone away since the last - * time we saw it, we don't need to vacuum it. + * Race condition -- if the pg_class tuple has gone away since the + * last time we saw it, we don't need to vacuum it. */ if (!SearchSysCacheExists(RELOID, ObjectIdGetDatum(relid), @@ -887,21 +894,24 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt, char expected_relkind) } /* - * Determine the type of lock we want --- hard exclusive lock for a FULL - * vacuum, but just ShareUpdateExclusiveLock for concurrent vacuum. Either - * way, we can be sure that no other backend is vacuuming the same table. + * Determine the type of lock we want --- hard exclusive lock for a + * FULL vacuum, but just ShareUpdateExclusiveLock for concurrent + * vacuum. Either way, we can be sure that no other backend is + * vacuuming the same table. */ lmode = vacstmt->full ? AccessExclusiveLock : ShareUpdateExclusiveLock; /* - * Open the class, get an appropriate lock on it, and check permissions. + * Open the class, get an appropriate lock on it, and check + * permissions. * - * We allow the user to vacuum a table if he is superuser, the table owner, - * or the database owner (but in the latter case, only if it's not a - * shared relation). pg_class_ownercheck includes the superuser case. + * We allow the user to vacuum a table if he is superuser, the table + * owner, or the database owner (but in the latter case, only if it's + * not a shared relation). pg_class_ownercheck includes the superuser + * case. * - * Note we choose to treat permissions failure as a WARNING and keep trying - * to vacuum the rest of the DB --- is this appropriate? + * Note we choose to treat permissions failure as a WARNING and keep + * trying to vacuum the rest of the DB --- is this appropriate? */ onerel = relation_open(relid, lmode); @@ -918,8 +928,8 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt, char expected_relkind) } /* - * Check that it's a plain table; we used to do this in get_rel_oids() but - * seems safer to check after we've locked the relation. + * Check that it's a plain table; we used to do this in get_rel_oids() + * but seems safer to check after we've locked the relation. */ if (onerel->rd_rel->relkind != expected_relkind) { @@ -944,14 +954,15 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt, char expected_relkind) relation_close(onerel, lmode); StrategyHintVacuum(false); CommitTransactionCommand(); - return true; /* assume no long-lived data in temp tables */ + return true; /* assume no long-lived data in temp + * tables */ } /* * Get a session-level lock too. This will protect our access to the * relation across multiple transactions, so that we can vacuum the - * relation's TOAST table (if any) secure in the knowledge that no one is - * deleting the parent relation. + * relation's TOAST table (if any) secure in the knowledge that no one + * is deleting the parent relation. * * NOTE: this cannot block, even if someone else is waiting for access, * because the lock manager knows that both lock requests are from the @@ -960,10 +971,14 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt, char expected_relkind) onerelid = onerel->rd_lockInfo.lockRelId; LockRelationForSession(&onerelid, lmode); - /* Remember the relation's TOAST relation for later */ + /* + * Remember the relation's TOAST relation for later + */ toast_relid = onerel->rd_rel->reltoastrelid; - /* Do the actual work --- either FULL or "lazy" vacuum */ + /* + * Do the actual work --- either FULL or "lazy" vacuum + */ if (vacstmt->full) full_vacuum_rel(onerel, vacstmt); else @@ -974,16 +989,18 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt, char expected_relkind) /* all done with this class, but hold lock until commit */ relation_close(onerel, NoLock); - /* Complete the transaction and free all temporary memory used. */ + /* + * Complete the transaction and free all temporary memory used. + */ StrategyHintVacuum(false); CommitTransactionCommand(); /* * If the relation has a secondary toast rel, vacuum that too while we * still hold the session lock on the master table. Note however that - * "analyze" will not get done on the toast table. This is good, because - * the toaster always uses hardcoded index access and statistics are - * totally unimportant for toast relations. + * "analyze" will not get done on the toast table. This is good, + * because the toaster always uses hardcoded index access and + * statistics are totally unimportant for toast relations. */ if (toast_relid != InvalidOid) { @@ -991,7 +1008,9 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt, char expected_relkind) result = false; /* failed to vacuum the TOAST table? */ } - /* Now release the session-level lock on the master table. */ + /* + * Now release the session-level lock on the master table. + */ UnlockRelationForSession(&onerelid, lmode); return result; @@ -1020,8 +1039,8 @@ full_vacuum_rel(Relation onerel, VacuumStmt *vacstmt) { VacPageListData vacuum_pages; /* List of pages to vacuum and/or * clean indexes */ - VacPageListData fraged_pages; /* List of pages with space enough for - * re-using */ + VacPageListData fraged_pages; /* List of pages with space enough + * for re-using */ Relation *Irel; int nindexes, i; @@ -1030,7 +1049,9 @@ full_vacuum_rel(Relation onerel, VacuumStmt *vacstmt) vacuum_set_xid_limits(vacstmt, onerel->rd_rel->relisshared, &OldestXmin, &FreezeLimit); - /* Set up statistics-gathering machinery. */ + /* + * Set up statistics-gathering machinery. + */ vacrelstats = (VRelStats *) palloc(sizeof(VRelStats)); vacrelstats->rel_pages = 0; vacrelstats->rel_tuples = 0; @@ -1178,8 +1199,8 @@ scan_heap(VRelStats *vacrelstats, Relation onerel, VacPage vacpagecopy; ereport(WARNING, - (errmsg("relation \"%s\" page %u is uninitialized --- fixing", - relname, blkno))); + (errmsg("relation \"%s\" page %u is uninitialized --- fixing", + relname, blkno))); PageInit(page, BufferGetPageSize(buf), 0); vacpage->free = ((PageHeader) page)->pd_upper - ((PageHeader) page)->pd_lower; free_space += vacpage->free; @@ -1244,8 +1265,8 @@ scan_heap(VRelStats *vacrelstats, Relation onerel, case HEAPTUPLE_LIVE: /* - * Tuple is good. Consider whether to replace its xmin - * value with FrozenTransactionId. + * Tuple is good. Consider whether to replace its + * xmin value with FrozenTransactionId. */ if (TransactionIdIsNormal(HeapTupleHeaderGetXmin(tuple.t_data)) && TransactionIdPrecedes(HeapTupleHeaderGetXmin(tuple.t_data), @@ -1257,7 +1278,9 @@ scan_heap(VRelStats *vacrelstats, Relation onerel, pgchanged = true; } - /* Other checks... */ + /* + * Other checks... + */ if (onerel->rd_rel->relhasoids && !OidIsValid(HeapTupleGetOid(&tuple))) elog(WARNING, "relation \"%s\" TID %u/%u: OID is invalid", @@ -1266,14 +1289,15 @@ scan_heap(VRelStats *vacrelstats, Relation onerel, case HEAPTUPLE_RECENTLY_DEAD: /* - * If tuple is recently deleted then we must not remove it - * from relation. + * If tuple is recently deleted then we must not + * remove it from relation. */ nkeep += 1; /* - * If we do shrinking and this tuple is updated one then - * remember it to construct updated tuple dependencies. + * If we do shrinking and this tuple is updated one + * then remember it to construct updated tuple + * dependencies. */ if (do_shrinking && !(ItemPointerEquals(&(tuple.t_self), @@ -1283,8 +1307,8 @@ scan_heap(VRelStats *vacrelstats, Relation onerel, { free_vtlinks = 1000; vtlinks = (VTupleLink) repalloc(vtlinks, - (free_vtlinks + num_vtlinks) * - sizeof(VTupleLinkData)); + (free_vtlinks + num_vtlinks) * + sizeof(VTupleLinkData)); } vtlinks[num_vtlinks].new_tid = tuple.t_data->t_ctid; vtlinks[num_vtlinks].this_tid = tuple.t_self; @@ -1295,10 +1319,10 @@ scan_heap(VRelStats *vacrelstats, Relation onerel, case HEAPTUPLE_INSERT_IN_PROGRESS: /* - * This should not happen, since we hold exclusive lock on - * the relation; shouldn't we raise an error? (Actually, - * it can happen in system catalogs, since we tend to - * release write lock before commit there.) + * This should not happen, since we hold exclusive + * lock on the relation; shouldn't we raise an error? + * (Actually, it can happen in system catalogs, since + * we tend to release write lock before commit there.) */ ereport(NOTICE, (errmsg("relation \"%s\" TID %u/%u: InsertTransactionInProgress %u --- can't shrink relation", @@ -1308,10 +1332,10 @@ scan_heap(VRelStats *vacrelstats, Relation onerel, case HEAPTUPLE_DELETE_IN_PROGRESS: /* - * This should not happen, since we hold exclusive lock on - * the relation; shouldn't we raise an error? (Actually, - * it can happen in system catalogs, since we tend to - * release write lock before commit there.) + * This should not happen, since we hold exclusive + * lock on the relation; shouldn't we raise an error? + * (Actually, it can happen in system catalogs, since + * we tend to release write lock before commit there.) */ ereport(NOTICE, (errmsg("relation \"%s\" TID %u/%u: DeleteTransactionInProgress %u --- can't shrink relation", @@ -1333,11 +1357,12 @@ scan_heap(VRelStats *vacrelstats, Relation onerel, ItemId lpp; /* - * Here we are building a temporary copy of the page with dead - * tuples removed. Below we will apply PageRepairFragmentation - * to the copy, so that we can determine how much space will - * be available after removal of dead tuples. But note we are - * NOT changing the real page yet... + * Here we are building a temporary copy of the page with + * dead tuples removed. Below we will apply + * PageRepairFragmentation to the copy, so that we can + * determine how much space will be available after + * removal of dead tuples. But note we are NOT changing + * the real page yet... */ if (tempPage == NULL) { @@ -1387,8 +1412,8 @@ scan_heap(VRelStats *vacrelstats, Relation onerel, /* * Add the page to fraged_pages if it has a useful amount of free * space. "Useful" means enough for a minimal-sized tuple. But we - * don't know that accurately near the start of the relation, so add - * pages unconditionally if they have >= BLCKSZ/10 free space. + * don't know that accurately near the start of the relation, so + * add pages unconditionally if they have >= BLCKSZ/10 free space. */ do_frag = (vacpage->free >= min_tlen || vacpage->free >= BLCKSZ / 10); @@ -1404,7 +1429,8 @@ scan_heap(VRelStats *vacrelstats, Relation onerel, /* * Include the page in empty_end_pages if it will be empty after - * vacuuming; this is to keep us from using it as a move destination. + * vacuuming; this is to keep us from using it as a move + * destination. */ if (notup) { @@ -1474,11 +1500,11 @@ scan_heap(VRelStats *vacrelstats, Relation onerel, RelationGetRelationName(onerel), tups_vacuumed, num_tuples, nblocks), errdetail("%.0f dead row versions cannot be removed yet.\n" - "Nonremovable row versions range from %lu to %lu bytes long.\n" + "Nonremovable row versions range from %lu to %lu bytes long.\n" "There were %.0f unused item pointers.\n" - "Total free space (including removable row versions) is %.0f bytes.\n" + "Total free space (including removable row versions) is %.0f bytes.\n" "%u pages are or will become empty, including %u at the end of the table.\n" - "%u pages containing %.0f free bytes are potential move destinations.\n" + "%u pages containing %.0f free bytes are potential move destinations.\n" "%s", nkeep, (unsigned long) min_tlen, (unsigned long) max_tlen, @@ -1551,14 +1577,14 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, vacpage->offsets_used = vacpage->offsets_free = 0; /* - * Scan pages backwards from the last nonempty page, trying to move tuples - * down to lower pages. Quit when we reach a page that we have moved any - * tuples onto, or the first page if we haven't moved anything, or when we - * find a page we cannot completely empty (this last condition is handled - * by "break" statements within the loop). + * Scan pages backwards from the last nonempty page, trying to move + * tuples down to lower pages. Quit when we reach a page that we have + * moved any tuples onto, or the first page if we haven't moved + * anything, or when we find a page we cannot completely empty (this + * last condition is handled by "break" statements within the loop). * - * NB: this code depends on the vacuum_pages and fraged_pages lists being in - * order by blkno. + * NB: this code depends on the vacuum_pages and fraged_pages lists being + * in order by blkno. */ nblocks = vacrelstats->rel_pages; for (blkno = nblocks - vacuum_pages->empty_end_pages - 1; @@ -1576,23 +1602,26 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, vacuum_delay_point(); /* - * Forget fraged_pages pages at or after this one; they're no longer - * useful as move targets, since we only want to move down. Note that - * since we stop the outer loop at last_move_dest_block, pages removed - * here cannot have had anything moved onto them already. + * Forget fraged_pages pages at or after this one; they're no + * longer useful as move targets, since we only want to move down. + * Note that since we stop the outer loop at last_move_dest_block, + * pages removed here cannot have had anything moved onto them + * already. * - * Also note that we don't change the stored fraged_pages list, only our - * local variable num_fraged_pages; so the forgotten pages are still - * available to be loaded into the free space map later. + * Also note that we don't change the stored fraged_pages list, only + * our local variable num_fraged_pages; so the forgotten pages are + * still available to be loaded into the free space map later. */ while (num_fraged_pages > 0 && - fraged_pages->pagedesc[num_fraged_pages - 1]->blkno >= blkno) + fraged_pages->pagedesc[num_fraged_pages - 1]->blkno >= blkno) { Assert(fraged_pages->pagedesc[num_fraged_pages - 1]->offsets_used == 0); --num_fraged_pages; } - /* Process this page of relation. */ + /* + * Process this page of relation. + */ buf = ReadBuffer(onerel, blkno); page = BufferGetPage(buf); @@ -1637,8 +1666,8 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, else Assert(!isempty); - chain_tuple_moved = false; /* no one chain-tuple was moved off - * this page, yet */ + chain_tuple_moved = false; /* no one chain-tuple was moved + * off this page, yet */ vacpage->blkno = blkno; maxoff = PageGetMaxOffsetNumber(page); for (offnum = FirstOffsetNumber; @@ -1658,36 +1687,38 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, ItemPointerSet(&(tuple.t_self), blkno, offnum); /* - * VACUUM FULL has an exclusive lock on the relation. So normally - * no other transaction can have pending INSERTs or DELETEs in - * this relation. A tuple is either (a) a tuple in a system - * catalog, inserted or deleted by a not yet committed transaction - * or (b) dead (XMIN_INVALID or XMAX_COMMITTED) or (c) inserted by - * a committed xact (XMIN_COMMITTED) or (d) moved by the currently - * running VACUUM. In case (a) we wouldn't be in repair_frag() at - * all. In case (b) we cannot be here, because scan_heap() has - * already marked the item as unused, see continue above. Case (c) - * is what normally is to be expected. Case (d) is only possible, - * if a whole tuple chain has been moved while processing this or - * a higher numbered block. + * VACUUM FULL has an exclusive lock on the relation. So + * normally no other transaction can have pending INSERTs or + * DELETEs in this relation. A tuple is either (a) a tuple in + * a system catalog, inserted or deleted by a not yet + * committed transaction or (b) dead (XMIN_INVALID or + * XMAX_COMMITTED) or (c) inserted by a committed xact + * (XMIN_COMMITTED) or (d) moved by the currently running + * VACUUM. In case (a) we wouldn't be in repair_frag() at all. + * In case (b) we cannot be here, because scan_heap() has + * already marked the item as unused, see continue above. Case + * (c) is what normally is to be expected. Case (d) is only + * possible, if a whole tuple chain has been moved while + * processing this or a higher numbered block. */ if (!(tuple.t_data->t_infomask & HEAP_XMIN_COMMITTED)) { /* - * There cannot be another concurrently running VACUUM. If the - * tuple had been moved in by a previous VACUUM, the + * There cannot be another concurrently running VACUUM. If + * the tuple had been moved in by a previous VACUUM, the * visibility check would have set XMIN_COMMITTED. If the - * tuple had been moved in by the currently running VACUUM, - * the loop would have been terminated. We had elog(ERROR, - * ...) here, but as we are testing for a can't-happen - * condition, Assert() seems more appropriate. + * tuple had been moved in by the currently running + * VACUUM, the loop would have been terminated. We had + * elog(ERROR, ...) here, but as we are testing for a + * can't-happen condition, Assert() seems more + * appropriate. */ Assert(!(tuple.t_data->t_infomask & HEAP_MOVED_IN)); /* - * If this (chain) tuple is moved by me already then I have to - * check is it in vacpage or not - i.e. is it moved while - * cleaning this page or some previous one. + * If this (chain) tuple is moved by me already then I + * have to check is it in vacpage or not - i.e. is it + * moved while cleaning this page or some previous one. */ Assert(tuple.t_data->t_infomask & HEAP_MOVED_OFF); @@ -1723,25 +1754,27 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, } /* - * If this tuple is in the chain of tuples created in updates by - * "recent" transactions then we have to move all chain of tuples - * to another places. + * If this tuple is in the chain of tuples created in updates + * by "recent" transactions then we have to move all chain of + * tuples to another places. * - * NOTE: this test is not 100% accurate: it is possible for a tuple - * to be an updated one with recent xmin, and yet not have a - * corresponding tuple in the vtlinks list. Presumably there was - * once a parent tuple with xmax matching the xmin, but it's - * possible that that tuple has been removed --- for example, if - * it had xmin = xmax then HeapTupleSatisfiesVacuum would deem it - * removable as soon as the xmin xact completes. + * NOTE: this test is not 100% accurate: it is possible for a + * tuple to be an updated one with recent xmin, and yet not + * have a corresponding tuple in the vtlinks list. Presumably + * there was once a parent tuple with xmax matching the xmin, + * but it's possible that that tuple has been removed --- for + * example, if it had xmin = xmax then + * HeapTupleSatisfiesVacuum would deem it removable as soon as + * the xmin xact completes. * - * To be on the safe side, we abandon the repair_frag process if we - * cannot find the parent tuple in vtlinks. This may be overly - * conservative; AFAICS it would be safe to move the chain. + * To be on the safe side, we abandon the repair_frag process if + * we cannot find the parent tuple in vtlinks. This may be + * overly conservative; AFAICS it would be safe to move the + * chain. */ if (((tuple.t_data->t_infomask & HEAP_UPDATED) && - !TransactionIdPrecedes(HeapTupleHeaderGetXmin(tuple.t_data), - OldestXmin)) || + !TransactionIdPrecedes(HeapTupleHeaderGetXmin(tuple.t_data), + OldestXmin)) || (!(tuple.t_data->t_infomask & (HEAP_XMAX_INVALID | HEAP_MARKED_FOR_UPDATE)) && !(ItemPointerEquals(&(tuple.t_self), @@ -1778,11 +1811,11 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, free_vtmove = 100; /* - * If this tuple is in the begin/middle of the chain then we - * have to move to the end of chain. + * If this tuple is in the begin/middle of the chain then + * we have to move to the end of chain. */ while (!(tp.t_data->t_infomask & (HEAP_XMAX_INVALID | - HEAP_MARKED_FOR_UPDATE)) && + HEAP_MARKED_FOR_UPDATE)) && !(ItemPointerEquals(&(tp.t_self), &(tp.t_data->t_ctid)))) { @@ -1798,17 +1831,17 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, ItemPointerGetBlockNumber(&Ctid)); Cpage = BufferGetPage(Cbuf); Citemid = PageGetItemId(Cpage, - ItemPointerGetOffsetNumber(&Ctid)); + ItemPointerGetOffsetNumber(&Ctid)); if (!ItemIdIsUsed(Citemid)) { /* - * This means that in the middle of chain there was - * tuple updated by older (than OldestXmin) xaction - * and this tuple is already deleted by me. Actually, - * upper part of chain should be removed and seems - * that this should be handled in scan_heap(), but - * it's not implemented at the moment and so we just - * stop shrinking here. + * This means that in the middle of chain there + * was tuple updated by older (than OldestXmin) + * xaction and this tuple is already deleted by + * me. Actually, upper part of chain should be + * removed and seems that this should be handled + * in scan_heap(), but it's not implemented at the + * moment and so we just stop shrinking here. */ elog(DEBUG2, "child itemid in update-chain marked as unused --- can't continue repair_frag"); chain_move_failed = true; @@ -1827,7 +1860,9 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, break; /* out of walk-along-page loop */ } - /* Check if all items in chain can be moved */ + /* + * Check if all items in chain can be moved + */ for (;;) { Buffer Pbuf; @@ -1878,8 +1913,8 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, /* At beginning of chain? */ if (!(tp.t_data->t_infomask & HEAP_UPDATED) || - TransactionIdPrecedes(HeapTupleHeaderGetXmin(tp.t_data), - OldestXmin)) + TransactionIdPrecedes(HeapTupleHeaderGetXmin(tp.t_data), + OldestXmin)) break; /* No, move to tuple with prior row version */ @@ -1899,10 +1934,10 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, } tp.t_self = vtlp->this_tid; Pbuf = ReadBuffer(onerel, - ItemPointerGetBlockNumber(&(tp.t_self))); + ItemPointerGetBlockNumber(&(tp.t_self))); Ppage = BufferGetPage(Pbuf); Pitemid = PageGetItemId(Ppage, - ItemPointerGetOffsetNumber(&(tp.t_self))); + ItemPointerGetOffsetNumber(&(tp.t_self))); /* this can't happen since we saw tuple earlier: */ if (!ItemIdIsUsed(Pitemid)) elog(ERROR, "parent itemid marked as unused"); @@ -1915,17 +1950,18 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, /* * Read above about cases when !ItemIdIsUsed(Citemid) - * (child item is removed)... Due to the fact that at the - * moment we don't remove unuseful part of update-chain, - * it's possible to get too old parent row here. Like as - * in the case which caused this problem, we stop - * shrinking here. I could try to find real parent row but - * want not to do it because of real solution will be - * implemented anyway, later, and we are too close to 6.5 - * release. - vadim 06/11/99 + * (child item is removed)... Due to the fact that at + * the moment we don't remove unuseful part of + * update-chain, it's possible to get too old parent + * row here. Like as in the case which caused this + * problem, we stop shrinking here. I could try to + * find real parent row but want not to do it because + * of real solution will be implemented anyway, later, + * and we are too close to 6.5 release. - vadim + * 06/11/99 */ if (!(TransactionIdEquals(HeapTupleHeaderGetXmax(Ptp.t_data), - HeapTupleHeaderGetXmin(tp.t_data)))) + HeapTupleHeaderGetXmin(tp.t_data)))) { ReleaseBuffer(Pbuf); elog(DEBUG2, "too old parent tuple found --- can't continue repair_frag"); @@ -1948,9 +1984,9 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, if (chain_move_failed) { /* - * Undo changes to offsets_used state. We don't bother - * cleaning up the amount-free state, since we're not - * going to do any further tuple motion. + * Undo changes to offsets_used state. We don't + * bother cleaning up the amount-free state, since + * we're not going to do any further tuple motion. */ for (i = 0; i < num_vtmove; i++) { @@ -1961,7 +1997,9 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, break; /* out of walk-along-page loop */ } - /* Okay, move the whole tuple chain */ + /* + * Okay, move the whole tuple chain + */ ItemPointerSetInvalid(&Ctid); for (ti = 0; ti < num_vtmove; ti++) { @@ -1972,7 +2010,7 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, /* Get page to move from */ tuple.t_self = vtmove[ti].tid; Cbuf = ReadBuffer(onerel, - ItemPointerGetBlockNumber(&(tuple.t_self))); + ItemPointerGetBlockNumber(&(tuple.t_self))); /* Get page to move to */ dst_buffer = ReadBuffer(onerel, destvacpage->blkno); @@ -1985,7 +2023,7 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, Cpage = BufferGetPage(Cbuf); Citemid = PageGetItemId(Cpage, - ItemPointerGetOffsetNumber(&(tuple.t_self))); + ItemPointerGetOffsetNumber(&(tuple.t_self))); tuple.t_datamcxt = NULL; tuple.t_data = (HeapTupleHeader) PageGetItem(Cpage, Citemid); tuple_len = tuple.t_len = ItemIdGetLength(Citemid); @@ -2069,16 +2107,19 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, } /* walk along page */ /* - * If we broke out of the walk-along-page loop early (ie, still have - * offnum <= maxoff), then we failed to move some tuple off this page. - * No point in shrinking any more, so clean up and exit the per-page - * loop. + * If we broke out of the walk-along-page loop early (ie, still + * have offnum <= maxoff), then we failed to move some tuple off + * this page. No point in shrinking any more, so clean up and + * exit the per-page loop. */ if (offnum < maxoff && keep_tuples > 0) { OffsetNumber off; - /* Fix vacpage state for any unvisited tuples remaining on page */ + /* + * Fix vacpage state for any unvisited tuples remaining on + * page + */ for (off = OffsetNumberNext(offnum); off <= maxoff; off = OffsetNumberNext(off)) @@ -2093,8 +2134,8 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, continue; /* - * * See comments in the walk-along-page loop above, why we * - * have Asserts here instead of if (...) elog(ERROR). + * * See comments in the walk-along-page loop above, why + * we * have Asserts here instead of if (...) elog(ERROR). */ Assert(!(htup->t_infomask & HEAP_MOVED_IN)); Assert(htup->t_infomask & HEAP_MOVED_OFF); @@ -2158,20 +2199,20 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, * We have to commit our tuple movings before we truncate the * relation. Ideally we should do Commit/StartTransactionCommand * here, relying on the session-level table lock to protect our - * exclusive access to the relation. However, that would require a - * lot of extra code to close and re-open the relation, indexes, etc. - * For now, a quick hack: record status of current transaction as - * committed, and continue. + * exclusive access to the relation. However, that would require + * a lot of extra code to close and re-open the relation, indexes, + * etc. For now, a quick hack: record status of current + * transaction as committed, and continue. */ RecordTransactionCommit(); } /* * We are not going to move any more tuples across pages, but we still - * need to apply vacuum_page to compact free space in the remaining pages - * in vacuum_pages list. Note that some of these pages may also be in the - * fraged_pages list, and may have had tuples moved onto them; if so, we - * already did vacuum_page and needn't do it again. + * need to apply vacuum_page to compact free space in the remaining + * pages in vacuum_pages list. Note that some of these pages may also + * be in the fraged_pages list, and may have had tuples moved onto + * them; if so, we already did vacuum_page and needn't do it again. */ for (i = 0, curpage = vacuum_pages->pagedesc; i < vacuumed_pages; @@ -2205,19 +2246,21 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, last_move_dest_block, num_moved); /* - * It'd be cleaner to make this report at the bottom of this routine, but - * then the rusage would double-count the second pass of index vacuuming. - * So do it here and ignore the relatively small amount of processing that - * occurs below. + * It'd be cleaner to make this report at the bottom of this routine, + * but then the rusage would double-count the second pass of index + * vacuuming. So do it here and ignore the relatively small amount of + * processing that occurs below. */ ereport(elevel, - (errmsg("\"%s\": moved %u row versions, truncated %u to %u pages", - RelationGetRelationName(onerel), - num_moved, nblocks, blkno), - errdetail("%s", - vac_show_rusage(&ru0)))); + (errmsg("\"%s\": moved %u row versions, truncated %u to %u pages", + RelationGetRelationName(onerel), + num_moved, nblocks, blkno), + errdetail("%s", + vac_show_rusage(&ru0)))); - /* Reflect the motion of system tuples to catalog cache here. */ + /* + * Reflect the motion of system tuples to catalog cache here. + */ CommandCounterIncrement(); if (Nvacpagelist.num_pages > 0) @@ -2231,7 +2274,7 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, /* re-sort Nvacpagelist.pagedesc */ for (vpleft = Nvacpagelist.pagedesc, - vpright = Nvacpagelist.pagedesc + Nvacpagelist.num_pages - 1; + vpright = Nvacpagelist.pagedesc + Nvacpagelist.num_pages - 1; vpleft < vpright; vpleft++, vpright--) { vpsave = *vpleft; @@ -2240,10 +2283,11 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, } /* - * keep_tuples is the number of tuples that have been moved off a - * page during chain moves but not been scanned over subsequently. - * The tuple ids of these tuples are not recorded as free offsets - * for any VacPage, so they will not be cleared from the indexes. + * keep_tuples is the number of tuples that have been moved + * off a page during chain moves but not been scanned over + * subsequently. The tuple ids of these tuples are not + * recorded as free offsets for any VacPage, so they will not + * be cleared from the indexes. */ Assert(keep_tuples >= 0); for (i = 0; i < nindexes; i++) @@ -2281,8 +2325,8 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, continue; /* - * * See comments in the walk-along-page loop above, why we * - * have Asserts here instead of if (...) elog(ERROR). + * * See comments in the walk-along-page loop above, why + * we * have Asserts here instead of if (...) elog(ERROR). */ Assert(!(htup->t_infomask & HEAP_MOVED_IN)); Assert(htup->t_infomask & HEAP_MOVED_OFF); @@ -2310,8 +2354,8 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, else { /* - * No XLOG record, but still need to flag that XID exists on - * disk + * No XLOG record, but still need to flag that XID exists + * on disk */ MyXactMadeTempRelUpdate = true; } @@ -2330,10 +2374,10 @@ repair_frag(VRelStats *vacrelstats, Relation onerel, } /* - * Flush dirty pages out to disk. We do this unconditionally, even if we - * don't need to truncate, because we want to ensure that all tuples have - * correct on-row commit status on disk (see bufmgr.c's comments for - * FlushRelationBuffers()). + * Flush dirty pages out to disk. We do this unconditionally, even if + * we don't need to truncate, because we want to ensure that all + * tuples have correct on-row commit status on disk (see bufmgr.c's + * comments for FlushRelationBuffers()). */ FlushRelationBuffers(onerel, blkno); @@ -2379,7 +2423,9 @@ move_chain_tuple(Relation rel, heap_copytuple_with_tuple(old_tup, &newtup); - /* register invalidation of source tuple in catcaches. */ + /* + * register invalidation of source tuple in catcaches. + */ CacheInvalidateHeapTuple(rel, old_tup); /* NO EREPORT(ERROR) TILL CHANGES ARE LOGGED */ @@ -2394,20 +2440,20 @@ move_chain_tuple(Relation rel, /* * If this page was not used before - clean it. * - * NOTE: a nasty bug used to lurk here. It is possible for the source and - * destination pages to be the same (since this tuple-chain member can be - * on a page lower than the one we're currently processing in the outer - * loop). If that's true, then after vacuum_page() the source tuple will - * have been moved, and tuple.t_data will be pointing at garbage. - * Therefore we must do everything that uses old_tup->t_data BEFORE this - * step!! + * NOTE: a nasty bug used to lurk here. It is possible for the source + * and destination pages to be the same (since this tuple-chain member + * can be on a page lower than the one we're currently processing in + * the outer loop). If that's true, then after vacuum_page() the + * source tuple will have been moved, and tuple.t_data will be + * pointing at garbage. Therefore we must do everything that uses + * old_tup->t_data BEFORE this step!! * - * This path is different from the other callers of vacuum_page, because we - * have already incremented the vacpage's offsets_used field to account - * for the tuple(s) we expect to move onto the page. Therefore - * vacuum_page's check for offsets_used == 0 is wrong. But since that's a - * good debugging check for all other callers, we work around it here - * rather than remove it. + * This path is different from the other callers of vacuum_page, because + * we have already incremented the vacpage's offsets_used field to + * account for the tuple(s) we expect to move onto the page. Therefore + * vacuum_page's check for offsets_used == 0 is wrong. But since + * that's a good debugging check for all other callers, we work around + * it here rather than remove it. */ if (!PageIsEmpty(dst_page) && cleanVpd) { @@ -2419,8 +2465,8 @@ move_chain_tuple(Relation rel, } /* - * Update the state of the copied tuple, and store it on the destination - * page. + * Update the state of the copied tuple, and store it on the + * destination page. */ newtup.t_data->t_infomask &= ~(HEAP_XMIN_COMMITTED | HEAP_XMIN_INVALID | @@ -2456,15 +2502,17 @@ move_chain_tuple(Relation rel, } else { - /* No XLOG record, but still need to flag that XID exists on disk */ + /* + * No XLOG record, but still need to flag that XID exists on disk + */ MyXactMadeTempRelUpdate = true; } END_CRIT_SECTION(); /* - * Set new tuple's t_ctid pointing to itself for last tuple in chain, and - * to next tuple in chain otherwise. + * Set new tuple's t_ctid pointing to itself for last tuple in chain, + * and to next tuple in chain otherwise. */ /* Is this ok after log_heap_move() and END_CRIT_SECTION()? */ if (!ItemPointerIsValid(ctid)) @@ -2515,15 +2563,17 @@ move_plain_tuple(Relation rel, * register invalidation of source tuple in catcaches. * * (Note: we do not need to register the copied tuple, because we are not - * changing the tuple contents and so there cannot be any need to flush - * negative catcache entries.) + * changing the tuple contents and so there cannot be any need to + * flush negative catcache entries.) */ CacheInvalidateHeapTuple(rel, old_tup); /* NO EREPORT(ERROR) TILL CHANGES ARE LOGGED */ START_CRIT_SECTION(); - /* Mark new tuple as MOVED_IN by me. */ + /* + * Mark new tuple as MOVED_IN by me. + */ newtup.t_data->t_infomask &= ~(HEAP_XMIN_COMMITTED | HEAP_XMIN_INVALID | HEAP_MOVED_OFF); @@ -2547,7 +2597,9 @@ move_plain_tuple(Relation rel, ItemPointerSet(&(newtup.t_data->t_ctid), dst_vacpage->blkno, newoff); newtup.t_self = newtup.t_data->t_ctid; - /* Mark old tuple as MOVED_OFF by me. */ + /* + * Mark old tuple as MOVED_OFF by me. + */ old_tup->t_data->t_infomask &= ~(HEAP_XMIN_COMMITTED | HEAP_XMIN_INVALID | HEAP_MOVED_IN); @@ -2567,7 +2619,9 @@ move_plain_tuple(Relation rel, } else { - /* No XLOG record, but still need to flag that XID exists on disk */ + /* + * No XLOG record, but still need to flag that XID exists on disk + */ MyXactMadeTempRelUpdate = true; } @@ -2644,8 +2698,8 @@ update_hint_bits(Relation rel, VacPageList fraged_pages, int num_fraged_pages, /* * See comments in the walk-along-page loop above, why we have - * Asserts here instead of if (...) elog(ERROR). The difference - * here is that we may see MOVED_IN. + * Asserts here instead of if (...) elog(ERROR). The + * difference here is that we may see MOVED_IN. */ Assert(htup->t_infomask & HEAP_MOVED); Assert(HeapTupleHeaderGetXvac(htup) == GetCurrentTransactionId()); @@ -2699,10 +2753,10 @@ vacuum_heap(VRelStats *vacrelstats, Relation onerel, VacPageList vacuum_pages) } /* - * Flush dirty pages out to disk. We do this unconditionally, even if we - * don't need to truncate, because we want to ensure that all tuples have - * correct on-row commit status on disk (see bufmgr.c's comments for - * FlushRelationBuffers()). + * Flush dirty pages out to disk. We do this unconditionally, even if + * we don't need to truncate, because we want to ensure that all + * tuples have correct on-row commit status on disk (see bufmgr.c's + * comments for FlushRelationBuffers()). */ Assert(vacrelstats->rel_pages >= vacuum_pages->empty_end_pages); relblocks = vacrelstats->rel_pages - vacuum_pages->empty_end_pages; @@ -2717,7 +2771,8 @@ vacuum_heap(VRelStats *vacrelstats, Relation onerel, VacPageList vacuum_pages) RelationGetRelationName(onerel), vacrelstats->rel_pages, relblocks))); RelationTruncate(onerel, relblocks); - vacrelstats->rel_pages = relblocks; /* set new number of blocks */ + vacrelstats->rel_pages = relblocks; /* set new number of + * blocks */ } } @@ -2781,9 +2836,9 @@ scan_index(Relation indrel, double num_tuples) /* * Even though we're not planning to delete anything, we use the - * ambulkdelete call, because (a) the scan happens within the index AM for - * more speed, and (b) it may want to pass private statistics to the - * amvacuumcleanup call. + * ambulkdelete call, because (a) the scan happens within the index AM + * for more speed, and (b) it may want to pass private statistics to + * the amvacuumcleanup call. */ stats = index_bulk_delete(indrel, dummy_tid_reaped, NULL); @@ -2802,18 +2857,18 @@ scan_index(Relation indrel, double num_tuples) false); ereport(elevel, - (errmsg("index \"%s\" now contains %.0f row versions in %u pages", - RelationGetRelationName(indrel), - stats->num_index_tuples, - stats->num_pages), - errdetail("%u index pages have been deleted, %u are currently reusable.\n" - "%s", - stats->pages_deleted, stats->pages_free, - vac_show_rusage(&ru0)))); + (errmsg("index \"%s\" now contains %.0f row versions in %u pages", + RelationGetRelationName(indrel), + stats->num_index_tuples, + stats->num_pages), + errdetail("%u index pages have been deleted, %u are currently reusable.\n" + "%s", + stats->pages_deleted, stats->pages_free, + vac_show_rusage(&ru0)))); /* - * Check for tuple count mismatch. If the index is partial, then it's OK - * for it to have fewer tuples than the heap; else we got trouble. + * Check for tuple count mismatch. If the index is partial, then it's + * OK for it to have fewer tuples than the heap; else we got trouble. */ if (stats->num_index_tuples != num_tuples) { @@ -2869,20 +2924,20 @@ vacuum_index(VacPageList vacpagelist, Relation indrel, false); ereport(elevel, - (errmsg("index \"%s\" now contains %.0f row versions in %u pages", - RelationGetRelationName(indrel), - stats->num_index_tuples, - stats->num_pages), - errdetail("%.0f index row versions were removed.\n" - "%u index pages have been deleted, %u are currently reusable.\n" - "%s", - stats->tuples_removed, - stats->pages_deleted, stats->pages_free, - vac_show_rusage(&ru0)))); + (errmsg("index \"%s\" now contains %.0f row versions in %u pages", + RelationGetRelationName(indrel), + stats->num_index_tuples, + stats->num_pages), + errdetail("%.0f index row versions were removed.\n" + "%u index pages have been deleted, %u are currently reusable.\n" + "%s", + stats->tuples_removed, + stats->pages_deleted, stats->pages_free, + vac_show_rusage(&ru0)))); /* - * Check for tuple count mismatch. If the index is partial, then it's OK - * for it to have fewer tuples than the heap; else we got trouble. + * Check for tuple count mismatch. If the index is partial, then it's + * OK for it to have fewer tuples than the heap; else we got trouble. */ if (stats->num_index_tuples != num_tuples + keep_tuples) { @@ -2891,7 +2946,7 @@ vacuum_index(VacPageList vacpagelist, Relation indrel, ereport(WARNING, (errmsg("index \"%s\" contains %.0f row versions, but table contains %.0f row versions", RelationGetRelationName(indrel), - stats->num_index_tuples, num_tuples + keep_tuples), + stats->num_index_tuples, num_tuples + keep_tuples), errhint("Rebuild the index with REINDEX."))); } @@ -2976,13 +3031,14 @@ vac_update_fsm(Relation onerel, VacPageList fraged_pages, /* * We only report pages with free space at least equal to the average - * request size --- this avoids cluttering FSM with uselessly-small bits - * of space. Although FSM would discard pages with little free space - * anyway, it's important to do this prefiltering because (a) it reduces - * the time spent holding the FSM lock in RecordRelationFreeSpace, and (b) - * FSM uses the number of pages reported as a statistic for guiding space - * management. If we didn't threshold our reports the same way - * vacuumlazy.c does, we'd be skewing that statistic. + * request size --- this avoids cluttering FSM with uselessly-small + * bits of space. Although FSM would discard pages with little free + * space anyway, it's important to do this prefiltering because (a) it + * reduces the time spent holding the FSM lock in + * RecordRelationFreeSpace, and (b) FSM uses the number of pages + * reported as a statistic for guiding space management. If we didn't + * threshold our reports the same way vacuumlazy.c does, we'd be + * skewing that statistic. */ threshold = GetAvgFSMRequestSize(&onerel->rd_node); @@ -2993,9 +3049,9 @@ vac_update_fsm(Relation onerel, VacPageList fraged_pages, for (i = 0; i < nPages; i++) { /* - * fraged_pages may contain entries for pages that we later decided to - * truncate from the relation; don't enter them into the free space - * map! + * fraged_pages may contain entries for pages that we later + * decided to truncate from the relation; don't enter them into + * the free space map! */ if (pagedesc[i]->blkno >= rel_pages) break; @@ -3021,7 +3077,7 @@ copy_vac_page(VacPage vacpage) /* allocate a VacPageData entry */ newvacpage = (VacPage) palloc(sizeof(VacPageData) + - vacpage->offsets_free * sizeof(OffsetNumber)); + vacpage->offsets_free * sizeof(OffsetNumber)); /* fill it in */ if (vacpage->offsets_free > 0) @@ -3191,7 +3247,7 @@ vac_open_indexes(Relation relation, LOCKMODE lockmode, } /* - * Release the resources acquired by vac_open_indexes. Optionally release + * Release the resources acquired by vac_open_indexes. Optionally release * the locks (say NoLock to keep 'em). */ void @@ -3218,7 +3274,10 @@ vac_close_indexes(int nindexes, Relation *Irel, LOCKMODE lockmode) bool vac_is_partial_index(Relation indrel) { - /* If the index's AM doesn't support nulls, it's partial for our purposes */ + /* + * If the index's AM doesn't support nulls, it's partial for our + * purposes + */ if (!indrel->rd_am->amindexnulls) return true; @@ -3295,9 +3354,9 @@ vac_show_rusage(VacRUsage *ru0) snprintf(result, sizeof(result), "CPU %d.%02ds/%d.%02du sec elapsed %d.%02d sec.", (int) (ru1.ru.ru_stime.tv_sec - ru0->ru.ru_stime.tv_sec), - (int) (ru1.ru.ru_stime.tv_usec - ru0->ru.ru_stime.tv_usec) / 10000, + (int) (ru1.ru.ru_stime.tv_usec - ru0->ru.ru_stime.tv_usec) / 10000, (int) (ru1.ru.ru_utime.tv_sec - ru0->ru.ru_utime.tv_sec), - (int) (ru1.ru.ru_utime.tv_usec - ru0->ru.ru_utime.tv_usec) / 10000, + (int) (ru1.ru.ru_utime.tv_usec - ru0->ru.ru_utime.tv_usec) / 10000, (int) (ru1.tv.tv_sec - ru0->tv.tv_sec), (int) (ru1.tv.tv_usec - ru0->tv.tv_usec) / 10000);