/*
* lazy_cleanup_index() -- do post-vacuum cleanup for one index relation.
*/
static void
lazy_cleanup_index(Relation indrel,
IndexBulkDeleteResult *stats,
LVRelStats *vacrelstats,
List *updated_stats)
{
IndexVacuumInfo ivinfo;
PGRUsage ru0;
pg_rusage_init(&ru0);
ivinfo.index = indrel;
ivinfo.vacuum_full = false;
ivinfo.message_level = elevel;
ivinfo.num_heap_tuples = vacrelstats->rel_tuples;
ivinfo.strategy = vac_strategy;
ivinfo.extra_oids = NIL;
stats = index_vacuum_cleanup(&ivinfo, stats);
if (!stats)
return;
/* now update statistics in pg_class */
vac_update_relstats_from_list(indrel,
stats->num_pages,
stats->num_index_tuples,
false,
InvalidTransactionId,
updated_stats);
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,
pg_rusage_show(&ru0))));
pfree(stats);
}
/*
* lazy_vacuum_aorel -- perform LAZY VACUUM for one Append-only relation.
*/
static void
lazy_vacuum_aorel(Relation onerel, VacuumStmt *vacstmt, List *updated_stats)
{
LVRelStats *vacrelstats;
bool update_relstats = true;
vacrelstats = (LVRelStats *) palloc0(sizeof(LVRelStats));
if (vacuumStatement_IsInAppendOnlyPreparePhase(vacstmt))
{
elogif(Debug_appendonly_print_compaction, LOG,
"Vacuum prepare phase %s", RelationGetRelationName(onerel));
vacuum_appendonly_indexes(onerel, vacstmt, updated_stats);
if (RelationIsAoRows(onerel))
AppendOnlyTruncateToEOF(onerel);
else
AOCSTruncateToEOF(onerel);
/*
* MPP-23647. For empty tables, we skip compaction phase
* and cleanup phase. Therefore, we update the stats
* (specifically, relfrozenxid) in prepare phase if the
* table is empty. Otherwise, the stats will be updated in
* the cleanup phase, when we would have computed the
* correct values for stats.
*/
if (vacstmt->appendonly_relation_empty)
{
update_relstats = true;
/*
* For an empty relation, the only stats we care about
* is relfrozenxid and relhasindex. We need to be
* mindful of correctly setting relhasindex here.
* relfrozenxid is already taken care of above by
* calling vacuum_set_xid_limits().
*/
vacrelstats->hasindex = onerel->rd_rel->relhasindex;
}
else
{
/*
* For a non-empty relation, follow the usual
* compaction phases and do not update stats in
* prepare phase.
*/
update_relstats = false;
}
}
else if (!vacummStatement_IsInAppendOnlyCleanupPhase(vacstmt))
{
vacuum_appendonly_rel(onerel, vacstmt);
update_relstats = false;
}
else
{
elogif(Debug_appendonly_print_compaction, LOG,
"Vacuum cleanup phase %s", RelationGetRelationName(onerel));
vacuum_appendonly_fill_stats(onerel, ActiveSnapshot,
&vacrelstats->rel_pages,
&vacrelstats->rel_tuples,
&vacrelstats->hasindex);
/* reset the remaining LVRelStats values */
vacrelstats->nonempty_pages = 0;
vacrelstats->num_dead_tuples = 0;
vacrelstats->max_dead_tuples = 0;
vacrelstats->tuples_deleted = 0;
vacrelstats->tot_free_pages = 0;
vacrelstats->fs_is_heap = false;
vacrelstats->num_free_pages = 0;
vacrelstats->max_free_pages = 0;
vacrelstats->pages_removed = 0;
}
if (update_relstats)
{
/* Update statistics in pg_class */
vac_update_relstats_from_list(onerel,
vacrelstats->rel_pages,
vacrelstats->rel_tuples,
vacrelstats->hasindex,
FreezeLimit,
updated_stats);
/* report results to the stats collector, too */
pgstat_report_vacuum(RelationGetRelid(onerel),
onerel->rd_rel->relisshared,
true /*vacrelstats->scanned_all*/,
vacstmt->analyze, vacrelstats->rel_tuples);
}
}
/*
* lazy_vacuum_rel() -- perform LAZY VACUUM for one heap relation
*
* This routine vacuums a single heap, cleans out its indexes, and
* updates its relpages and reltuples statistics.
*
* At entry, we have already established a transaction and opened
* and locked the relation.
*
* The return value indicates whether this function has held off
* interrupts -- caller must RESUME_INTERRUPTS() after commit if true.
*/
bool
lazy_vacuum_rel(Relation onerel, VacuumStmt *vacstmt,
BufferAccessStrategy bstrategy, List *updated_stats)
{
LVRelStats *vacrelstats;
Relation *Irel;
int nindexes;
BlockNumber possibly_freeable;
PGRUsage ru0;
TimestampTz starttime = 0;
bool heldoff = false;
pg_rusage_init(&ru0);
/* measure elapsed time iff autovacuum logging requires it */
if (IsAutoVacuumWorkerProcess() && Log_autovacuum_min_duration > 0)
starttime = GetCurrentTimestamp();
if (vacstmt->verbose)
elevel = INFO;
else
elevel = DEBUG2;
if (Gp_role == GP_ROLE_DISPATCH)
elevel = DEBUG2; /* vacuum and analyze messages aren't interesting from the QD */
#ifdef FAULT_INJECTOR
if (vacuumStatement_IsInAppendOnlyDropPhase(vacstmt))
{
FaultInjector_InjectFaultIfSet(
CompactionBeforeSegmentFileDropPhase,
DDLNotSpecified,
"", // databaseName
""); // tableName
}
if (vacummStatement_IsInAppendOnlyCleanupPhase(vacstmt))
{
FaultInjector_InjectFaultIfSet(
CompactionBeforeCleanupPhase,
DDLNotSpecified,
"", // databaseName
""); // tableName
}
#endif
/*
* MPP-23647. Update xid limits for heap as well as appendonly
* relations. This allows setting relfrozenxid to correct value
* for an appendonly (AO/CO) table.
*/
vac_strategy = bstrategy;
vacuum_set_xid_limits(vacstmt->freeze_min_age, onerel->rd_rel->relisshared,
&OldestXmin, &FreezeLimit);
/*
* Execute the various vacuum operations. Appendonly tables are treated
* differently.
*/
if (RelationIsAoRows(onerel) || RelationIsAoCols(onerel))
{
lazy_vacuum_aorel(onerel, vacstmt, updated_stats);
return false;
}
vacrelstats = (LVRelStats *) palloc0(sizeof(LVRelStats));
/* heap relation */
/* Set threshold for interesting free space = average request size */
/* XXX should we scale it up or down? Adjust vacuum.c too, if so */
vacrelstats->threshold = GetAvgFSMRequestSize(&onerel->rd_node);
vacrelstats->num_index_scans = 0;
/* Open all indexes of the relation */
vac_open_indexes(onerel, RowExclusiveLock, &nindexes, &Irel);
vacrelstats->hasindex = (nindexes > 0);
/* Do the vacuuming */
lazy_scan_heap(onerel, vacrelstats, Irel, nindexes, updated_stats);
/* Done with indexes */
vac_close_indexes(nindexes, Irel, NoLock);
/*
* Optionally truncate the relation.
*
* Don't even think about it unless we have a shot at releasing a goodly
* number of pages. Otherwise, the time taken isn't worth it.
*
* Note that after we've truncated the heap, it's too late to abort the
* transaction; doing so would lose the sinval messages needed to tell
* the other backends about the table being shrunk. We prevent interrupts
* in that case; caller is responsible for re-enabling them after
* committing the transaction.
*/
possibly_freeable = vacrelstats->rel_pages - vacrelstats->nonempty_pages;
if (possibly_freeable > 0 &&
(possibly_freeable >= REL_TRUNCATE_MINIMUM ||
possibly_freeable >= vacrelstats->rel_pages / REL_TRUNCATE_FRACTION))
{
HOLD_INTERRUPTS();
heldoff = true;
lazy_truncate_heap(onerel, vacrelstats);
}
/* Update shared free space map with final free space info */
lazy_update_fsm(onerel, vacrelstats);
if (vacrelstats->tot_free_pages > MaxFSMPages)
ereport(WARNING,
(errmsg("relation \"%s.%s\" contains more than \"max_fsm_pages\" pages with useful free space",
get_namespace_name(RelationGetNamespace(onerel)),
RelationGetRelationName(onerel)),
/* Only suggest VACUUM FULL if > 20% free */
(vacrelstats->tot_free_pages > vacrelstats->rel_pages * 0.20) ?
errhint("Consider using VACUUM FULL on this relation or increasing the configuration parameter \"max_fsm_pages\".") :
errhint("Consider increasing the configuration parameter \"max_fsm_pages\".")));
/* Update statistics in pg_class */
vac_update_relstats_from_list(onerel,
vacrelstats->rel_pages,
vacrelstats->rel_tuples,
vacrelstats->hasindex,
FreezeLimit,
updated_stats);
/* report results to the stats collector, too */
pgstat_report_vacuum(RelationGetRelid(onerel), onerel->rd_rel->relisshared,
true /*vacrelstats->scanned_all*/,
vacstmt->analyze, vacrelstats->rel_tuples);
if (gp_indexcheck_vacuum == INDEX_CHECK_ALL ||
(gp_indexcheck_vacuum == INDEX_CHECK_SYSTEM &&
PG_CATALOG_NAMESPACE == RelationGetNamespace(onerel)))
{
int i;
for (i = 0; i < nindexes; i++)
{
if (Irel[i]->rd_rel->relam == BTREE_AM_OID)
_bt_validate_vacuum(Irel[i], onerel, OldestXmin);
}
}
/* and log the action if appropriate */
if (IsAutoVacuumWorkerProcess() && Log_autovacuum_min_duration >= 0)
{
if (Log_autovacuum_min_duration == 0 ||
TimestampDifferenceExceeds(starttime, GetCurrentTimestamp(),
Log_autovacuum_min_duration))
ereport(LOG,
(errmsg("automatic vacuum of table \"%s.%s.%s\": index scans: %d\n"
"pages: %d removed, %d remain\n"
"tuples: %.0f removed, %.0f remain\n"
"system usage: %s",
get_database_name(MyDatabaseId),
get_namespace_name(RelationGetNamespace(onerel)),
RelationGetRelationName(onerel),
vacrelstats->num_index_scans,
vacrelstats->pages_removed, vacrelstats->rel_pages,
vacrelstats->tuples_deleted, vacrelstats->rel_tuples,
pg_rusage_show(&ru0))));
}
return heldoff;
}
