</listitem>

</varlistentry>

<varlistentry id="guc-vacuum-freeze-strategy-threshold" xreflabel="vacuum_freeze_strategy_threshold">

<term><varname>vacuum_freeze_strategy_threshold</varname> (<type>integer</type>)

<indexterm>

<primary><varname>vacuum_freeze_strategy_threshold</varname> configuration parameter</primary>

</indexterm>

</term>

<listitem>

<para>

Specifies the cutoff storage size that

<command>VACUUM</command> should use to determine its freezing

strategy. This is applied by comparing it to the size of the

target table's <glossterm linkend="glossary-fork">main

fork</glossterm> at the beginning of each <command>VACUUM</command>.

Eager freezing strategy is used by <command>VACUUM</command>

when the table's main fork size exceeds this value.

<command>VACUUM</command> <emphasis>always</emphasis> uses

eager freezing strategy when processing <glossterm

linkend="glossary-unlogged">unlogged</glossterm> tables,

regardless of this setting. Otherwise <command>VACUUM</command>

uses lazy freezing strategy. For more information see <xref

linkend="vacuum-for-wraparound"/>.

</para>

<para>

If this value is specified without units, it is taken as

megabytes. The default is four gigabytes

(<literal>4GB</literal>).

</para>

</listitem>

</varlistentry>

<varlistentry id="guc-vacuum-failsafe-age" xreflabel="vacuum_failsafe_age">

<term><varname>vacuum_failsafe_age</varname> (<type>integer</type>)

<indexterm>

</note>

<para>

<xref linkend="guc-vacuum-freeze-strategy-threshold"/> controls

<command>VACUUM</command>'s freezing strategy. The

<firstterm>eager freezing strategy</firstterm> makes

<command>VACUUM</command> freeze all rows on a page whenever each

and every row on the page is considered visible to all current

transactions (immediately after dead row versions are removed).

Freezing pages early and in batch often spreads out the overhead

of freezing over time. <command>VACUUM</command> consistently

avoids allowing unfrozen all-visible pages to build up, improving

system level performance stability. The <firstterm>lazy freezing

strategy</firstterm> makes <command>VACUUM</command> determine

whether pages should be frozen on the basis of the age of the

oldest XID on the page. Freezing pages lazily sometimes avoids

the overhead of freezing that turns out to have been unnecessary

because the rows were modified soon after freezing took place.

</para>

<para>

<xref linkend="guc-vacuum-freeze-min-age"/> controls how old an

XID value has to be before pages with rows bearing that XID are

frozen. This setting is an additional trigger criteria for

freezing a page's tuples. It is used by both freezing strategies,

though it typically has little impact when <command>VACUUM</command>

uses the eager freezing strategy.

<xref linkend="guc-vacuum-freeze-min-age"/>

controls how old an XID value has to be before rows bearing that XID will be

frozen. Increasing this setting may avoid unnecessary work if the

rows that would otherwise be frozen will soon be modified again,

but decreasing this setting increases

the number of transactions that can elapse before the table must be

vacuumed again.

</para>

<para>

always use its aggressive strategy.

</para>

<para>

Controlling the overhead of freezing existing all-visible pages

during aggressive vacuuming is the goal of the eager freezing

strategy. Increasing <varname>vacuum_freeze_strategy_threshold</varname>

may avoid unnecessary work, but it increases the risk of an

eventual aggressive vacuum that performs an excessive amount of

<quote>catch up</quote> freezing all at once.

</para>

<para>

The maximum time that a table can go unvacuumed is two billion

transactions minus the <varname>vacuum_freeze_min_age</varname> value at

the time of the last aggressive vacuum. If it were to go

unvacuumed for longer than that, the system could temporarily refuse to

allocate new transaction IDs. To ensure that thisnever happens,

unvacuumed for longer than

that, data loss could result. To ensure that thisdoes not happen,

autovacuum is invoked on any table that might contain unfrozen rows with

XIDs older than the age specified by the configuration parameter <xref

linkend="guc-autovacuum-freeze-max-age"/>. (This will happen even if

</para>

<para>

One disadvantage of increasing <varname>autovacuum_freeze_max_age</varname>

The sole disadvantage of increasing <varname>autovacuum_freeze_max_age</varname>

(and <varname>vacuum_freeze_table_age</varname> along with it) is that

the <filename>pg_xact</filename> and <filename>pg_commit_ts</filename>

subdirectories of the database cluster will take more space, because it

For tables which receive <command>INSERT</command> operations but no or

almost no <command>UPDATE</command>/<command>DELETE</command> operations,

it may be beneficial to lower the table's

<xref linkend="reloption-autovacuum-freeze-strategy-threshold"/>

toallow freezing to take place proactively. The number of obsolete tuples and

<xref linkend="reloption-autovacuum-freeze-min-age"/> as this may allow

tuplestobe frozen by earlier vacuums. The number of obsolete tuples and

the number of inserted tuples are obtained from the cumulative statistics system;

it is a semi-accurate count updated by each <command>UPDATE</command>,

<command>DELETE</command> and <command>INSERT</command> operation. (It is

</listitem>

</varlistentry>

<varlistentry id="reloption-autovacuum-freeze-strategy-threshold" xreflabel="autovacuum_freeze_strategy_threshold">

<term><literal>autovacuum_freeze_strategy_threshold</literal>, <literal>toast.autovacuum_freeze_strategy_threshold</literal> (<type>integer</type>)

<indexterm>

<primary><varname>autovacuum_freeze_strategy_threshold</varname> storage parameter</primary>

</indexterm>

</term>

<listitem>

<para>

Per-table value for <xref linkend="guc-vacuum-freeze-strategy-threshold"/>

parameter.

</para>

</listitem>

</varlistentry>

<varlistentry id="reloption-log-autovacuum-min-duration" xreflabel="log_autovacuum_min_duration">

<term><literal>log_autovacuum_min_duration</literal>, <literal>toast.log_autovacuum_min_duration</literal> (<type>integer</type>)

<indexterm>

},-1,0,2000000000

},

{

{

"autovacuum_freeze_strategy_threshold",

"Table size at which VACUUM freezes using eager strategy, in megabytes.",

RELOPT_KIND_HEAP |RELOPT_KIND_TOAST,

},-1,0,MAX_KILOBYTES

},

{

{

"log_autovacuum_min_duration",

offsetof(StdRdOptions,autovacuum)+ offsetof(AutoVacOpts,multixact_freeze_max_age)},

{"autovacuum_multixact_freeze_table_age",RELOPT_TYPE_INT,

offsetof(StdRdOptions,autovacuum)+ offsetof(AutoVacOpts,multixact_freeze_table_age)},

{"autovacuum_freeze_strategy_threshold",RELOPT_TYPE_INT,

offsetof(StdRdOptions,autovacuum)+ offsetof(AutoVacOpts,freeze_strategy_threshold)},

{"log_autovacuum_min_duration",RELOPT_TYPE_INT,

offsetof(StdRdOptions,autovacuum)+ offsetof(AutoVacOpts,log_min_duration)},

{"toast_tuple_target",RELOPT_TYPE_INT,

cutoffs.OldestMxact=MultiXactCutoff;

cutoffs.FreezeLimit=FreezeLimit;

cutoffs.MultiXactCutoff=MultiXactCutoff;

cutoffs.freeze_strategy_threshold_pages=0;

pagefrz.freeze_required= true;

pagefrz.FreezePageRelfrozenXid=FreezeLimit;

boolaggressive;

boolskipwithvm;

booleager_freeze_strategy;

boolfailsafe_active;

staticvoidlazy_scan_heap(LVRelState*vacrel);

staticvoidlazy_scan_strategy(LVRelState*vacrel);

staticBlockNumberlazy_scan_skip(LVRelState*vacrel,Buffer*vmbuffer,

BlockNumbernext_block,

bool*next_unskippable_allvis,

vacrel->skipwithvm=skipwithvm;

lazy_scan_strategy(vacrel);

if (verbose)

{

if (vacrel->aggressive)

lazy_cleanup_all_indexes(vacrel);

}

lazy_scan_strategy(LVRelState*vacrel)

{

BlockNumberrel_pages=vacrel->rel_pages;

(rel_pages>vacrel->cutoffs.freeze_strategy_threshold_pages||

!RelationIsPermanent(vacrel->rel));

}

if (pagefrz.freeze_required||tuples_frozen==0||

(prunestate->all_visible&&prunestate->all_frozen&&

(fpi_before!=pgWalUsage.wal_fpi||vacrel->eager_freeze_strategy)))

fpi_before!=pgWalUsage.wal_fpi))

{

intvacuum_freeze_table_age;

intvacuum_multixact_freeze_min_age;

intvacuum_multixact_freeze_table_age;

intvacuum_freeze_strategy_threshold;

intvacuum_failsafe_age;

intvacuum_multixact_failsafe_age;

params.freeze_table_age=0;

params.multixact_freeze_min_age=0;

params.multixact_freeze_table_age=0;

params.freeze_strategy_threshold=0;

}

{

params.freeze_min_age=-1;

params.freeze_table_age=-1;

params.multixact_freeze_min_age=-1;

params.multixact_freeze_table_age=-1;

params.freeze_strategy_threshold=-1;

}

multixact_freeze_min_age,

freeze_table_age,

multixact_freeze_table_age,

effective_multixact_freeze_max_age,

freeze_strategy_threshold;

uint64threshold_strategy_pages;

effective_multixact_freeze_max_age;

TransactionIdnextXID,

safeOldestXmin,

aggressiveXIDCutoff;

multixact_freeze_min_age=params->multixact_freeze_min_age;

freeze_table_age=params->freeze_table_age;

multixact_freeze_table_age=params->multixact_freeze_table_age;

freeze_strategy_threshold=params->freeze_strategy_threshold;

cutoffs->relfrozenxid=rel->rd_rel->relfrozenxid;

if (MultiXactIdPrecedes(cutoffs->OldestMxact,cutoffs->MultiXactCutoff))

cutoffs->MultiXactCutoff=cutoffs->OldestMxact;

if (freeze_strategy_threshold<0)

freeze_strategy_threshold=vacuum_freeze_strategy_threshold;

Assert(freeze_strategy_threshold >=0);

((uint64)freeze_strategy_threshold*1024*1024) /BLCKSZ;

threshold_strategy_pages=Min(threshold_strategy_pages,MaxBlockNumber);

cutoffs->freeze_strategy_threshold_pages=threshold_strategy_pages;

staticintdefault_freeze_table_age;

staticintdefault_multixact_freeze_min_age;

staticintdefault_multixact_freeze_table_age;

staticintdefault_freeze_strategy_threshold;

staticMemoryContextAutovacMemCxt;

default_freeze_table_age=0;

default_multixact_freeze_min_age=0;

default_multixact_freeze_table_age=0;

default_freeze_strategy_threshold=0;

}

{

default_freeze_min_age=vacuum_freeze_min_age;

default_freeze_table_age=vacuum_freeze_table_age;

default_multixact_freeze_min_age=vacuum_multixact_freeze_min_age;

default_multixact_freeze_table_age=vacuum_multixact_freeze_table_age;

default_freeze_strategy_threshold=vacuum_freeze_strategy_threshold;

}

ReleaseSysCache(tuple);

intfreeze_table_age;

intmultixact_freeze_min_age;

intmultixact_freeze_table_age;

intfreeze_strategy_threshold;

intvac_cost_limit;

doublevac_cost_delay;

intlog_min_duration;

?avopts->multixact_freeze_table_age

:default_multixact_freeze_table_age;

freeze_strategy_threshold= (avopts&&

avopts->freeze_strategy_threshold >=0)

?avopts->freeze_strategy_threshold

:default_freeze_strategy_threshold;

tab=palloc(sizeof(autovac_table));

tab->at_relid=relid;

tab->at_sharedrel=classForm->relisshared;

tab->at_params.freeze_table_age=freeze_table_age;

tab->at_params.multixact_freeze_min_age=multixact_freeze_min_age;

tab->at_params.multixact_freeze_table_age=multixact_freeze_table_age;

tab->at_params.freeze_strategy_threshold=freeze_strategy_threshold;

tab->at_params.is_wraparound=wraparound;

tab->at_params.log_min_duration=log_min_duration;

tab->at_vacuum_cost_limit=vac_cost_limit;

NULL,NULL,NULL

},

{

{"vacuum_freeze_strategy_threshold",PGC_USERSET,CLIENT_CONN_STATEMENT,

gettext_noop("Table size at which VACUUM freezes using eager strategy, in megabytes."),

gettext_noop("This is applied by comparing it to the size of a table's main fork at "

"Otherwise lazy freezing strategy is used."),

},

&vacuum_freeze_strategy_threshold,

4096,0,MAX_KILOBYTES,

NULL,NULL,NULL

},

{

{"vacuum_defer_cleanup_age",PGC_SIGHUP,REPLICATION_PRIMARY,

gettext_noop("Number of transactions by which VACUUM and HOT cleanup should be deferred, if any."),