</listitem>

</varlistentry>

<varlistentry>

<term><literal>vacuum_index_cleanup</literal> (<type>boolean</type>)</term>

<listitem>

<para>

Enables or disables index cleanup when <command>VACUUM</command> is

run on this table. The default value is <literal>true</literal>.

Disabling index cleanup can speed up <command>VACUUM</command> very

significantly, but may also lead to severely bloated indexes if table

modifications are frequent. The <literal>INDEX_CLEANUP</literal>

parameter to <xref linkend="sql-vacuum"/>, if specified, overrides

the value of this option.

</para>

</listitem>

</varlistentry>

<varlistentry>

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

<listitem>

ANALYZE [ <replaceable class="parameter">boolean</replaceable> ]

DISABLE_PAGE_SKIPPING [ <replaceable class="parameter">boolean</replaceable> ]

SKIP_LOCKED [ <replaceable class="parameter">boolean</replaceable> ]

INDEX_CLEANUP [ <replaceable class="parameter">boolean</replaceable> ]

<phrase>and <replaceable class="parameter">table_and_columns</replaceable> is:</phrase>

</listitem>

</varlistentry>

<varlistentry>

<term><literal>INDEX_CLEANUP</literal></term>

<listitem>

<para>

Specifies that <command>VACUUM</command> should attempt to remove

index entries pointing to dead tuples. This is normally the desired

behavior and is the default unless the

<literal>vacuum_index_cleanup</literal> option has been set to false

for the table to be vacuumed. Setting this option to false may be

useful when it is necessary to make vacuum run as quickly as possible,

for example to avoid imminent transaction ID wraparound

(see <xref linkend="vacuum-for-wraparound"/>). However, if index

cleanup is not performed regularly, performance may suffer, because

as the table is modified, indexes will accumulate dead tuples

and the table itself will accumulate dead line pointers that cannot be

removed until index cleanup is completed. This option has no effect

for tables that do not have an index and is ignored if the

<literal>FULL</literal> is used.

</para>

</listitem>

</varlistentry>

<varlistentry>

<term><replaceable class="parameter">boolean</replaceable></term>

<listitem>

},

false

},

{

{

"vacuum_index_cleanup",

"Enables index vacuuming and index cleanup",

RELOPT_KIND_HEAP,

},

true

},

{{NULL}}

};

{"parallel_workers",RELOPT_TYPE_INT,

offsetof(StdRdOptions,parallel_workers)},

{"vacuum_cleanup_index_scale_factor",RELOPT_TYPE_REAL,

offsetof(StdRdOptions,vacuum_cleanup_index_scale_factor)}

offsetof(StdRdOptions,vacuum_cleanup_index_scale_factor)},

{"vacuum_index_cleanup",RELOPT_TYPE_BOOL,

offsetof(StdRdOptions,vacuum_index_cleanup)}

};

options=parseRelOptions(reloptions,validate,kind,&numoptions);

{

boolhasindex;

booluseindex;

BlockNumberold_rel_pages;/* previous value of pg_class.relpages */

BlockNumberrel_pages;/* total number of pages */

doublenew_rel_tuples;/* new estimated total # of tuples */

doublenew_live_tuples;/* new estimated total # of live tuples */

doublenew_dead_tuples;/* new estimated total # of dead tuples */

doublenleft_dead_tuples;/* # of dead tuples we left */

doublenleft_dead_itemids;/* # of dead item pointers we left */

BlockNumberpages_removed;

doubletuples_deleted;

BlockNumbernonempty_pages;/* actually, last nonempty page + 1 */

staticvoidlazy_scan_heap(Relationonerel,intoptions,

staticvoidlazy_scan_heap(Relationonerel,VacuumParams*params,

LVRelStats*vacrelstats,Relation*Irel,intnindexes,

boolaggressive);

staticvoidlazy_vacuum_heap(Relationonerel,LVRelStats*vacrelstats,BlockNumbernblocks);

MultiXactIdnew_min_multi;

Assert(params!=NULL);

Assert(params->index_cleanup!=VACOPT_TERNARY_DEFAULT);

if (IsAutoVacuumWorkerProcess()&&params->log_min_duration >=0)

vac_open_indexes(onerel,RowExclusiveLock,&nindexes,&Irel);

vacrelstats->hasindex= (nindexes>0);

vacrelstats->useindex= (nindexes>0&&

params->index_cleanup==VACOPT_TERNARY_ENABLED);

lazy_scan_heap(onerel,params->options,vacrelstats,Irel,nindexes,aggressive);

lazy_scan_heap(onerel,params,vacrelstats,Irel,nindexes,aggressive);

vac_close_indexes(nindexes,Irel,NoLock);

new_rel_pages,

new_live_tuples,

new_rel_allvisible,

vacrelstats->hasindex,

nindexes>0,

new_frozen_xid,

new_min_multi,

false);

vacrelstats->new_rel_tuples,

vacrelstats->new_dead_tuples,

OldestXmin);

if (vacrelstats->nleft_dead_tuples>0||

vacrelstats->nleft_dead_itemids>0)

appendStringInfo(&buf,

_("%.0f tuples and %.0f item identifiers are left as dead.\n"),

vacrelstats->nleft_dead_tuples,

vacrelstats->nleft_dead_itemids);

appendStringInfo(&buf,

_("buffer usage: %d hits, %d misses, %d dirtied\n"),

VacuumPageHit,

lazy_scan_heap(Relationonerel,intoptions,LVRelStats*vacrelstats,

lazy_scan_heap(Relationonerel,VacuumParams*params,LVRelStats*vacrelstats,

Relation*Irel,intnindexes,boolaggressive)

{

BlockNumbernblocks,

live_tuples,/* live tuples (reltuples estimate) */

tups_vacuumed,/* tuples cleaned up by vacuum */

nkeep,/* dead-but-not-removable tuples */

nunused;/* unused item pointers */

nunused,/* unused item pointers */

nleft_dead_tuples,/* tuples we left as dead */

nleft_dead_itemids;/* item pointers we left as dead,

IndexBulkDeleteResult**indstats;

inti;

PGRUsageru0;

empty_pages=vacuumed_pages=0;

next_fsm_block_to_vacuum= (BlockNumber)0;

num_tuples=live_tuples=tups_vacuumed=nkeep=nunused=0;

nleft_dead_itemids=nleft_dead_tuples=0;

indstats= (IndexBulkDeleteResult**)

palloc0(nindexes*sizeof(IndexBulkDeleteResult*));

next_unskippable_block=0;

if ((options&VACOPT_DISABLE_PAGE_SKIPPING)==0)

if ((params->options&VACOPT_DISABLE_PAGE_SKIPPING)==0)

{

while (next_unskippable_block<nblocks)

{

{

next_unskippable_block++;

if ((options&VACOPT_DISABLE_PAGE_SKIPPING)==0)

if ((params->options&VACOPT_DISABLE_PAGE_SKIPPING)==0)

{

while (next_unskippable_block<nblocks)

{

HeapTupleIsHeapOnly(&tuple))

nkeep+=1;

{

tupgone= true;/* we can delete the tuple */

if (params->index_cleanup==VACOPT_TERNARY_ENABLED)

nleft_dead_tuples++;

}

all_visible= false;

break;

caseHEAPTUPLE_LIVE:

}

if (nindexes==0&&

vacrelstats->num_dead_tuples>0)

if (!vacrelstats->useindex&&vacrelstats->num_dead_tuples>0)

{

lazy_vacuum_page(onerel,blkno,buf,0,vacrelstats,&vmbuffer);

has_dead_tuples= false;

if (nindexes==0)

{

lazy_vacuum_page(onerel,blkno,buf,0,vacrelstats,&vmbuffer);

vacuumed_pages++;

has_dead_tuples= false;

}

{

Assert(params->index_cleanup==VACOPT_TERNARY_DISABLED);

nleft_dead_itemids+=vacrelstats->num_dead_tuples;

}

vacrelstats->num_dead_tuples=0;

vacuumed_pages++;

RecordPageWithFreeSpace(onerel,blkno,freespace,nblocks);

}

Assert((params->index_cleanup==VACOPT_TERNARY_ENABLED&&

nleft_dead_tuples==0&&nleft_dead_itemids==0)||

params->index_cleanup==VACOPT_TERNARY_DISABLED);

pgstat_progress_update_param(PROGRESS_VACUUM_HEAP_BLKS_SCANNED,blkno);

pfree(frozen);

vacrelstats->tuples_deleted=tups_vacuumed;

vacrelstats->new_dead_tuples=nkeep;

vacrelstats->new_dead_tuples=nkeep+nleft_dead_tuples;

vacrelstats->nleft_dead_tuples=nleft_dead_tuples;

vacrelstats->nleft_dead_itemids=nleft_dead_itemids;

vacrelstats->new_live_tuples=vac_estimate_reltuples(onerel,

PROGRESS_VACUUM_PHASE_INDEX_CLEANUP);

for (i=0;i<nindexes;i++)

lazy_cleanup_index(Irel[i],indstats[i],vacrelstats);

if (vacrelstats->useindex)

{

for (i=0;i<nindexes;i++)

lazy_cleanup_index(Irel[i],indstats[i],vacrelstats);

}

if (vacuumed_pages)

"%u pages are entirely empty.\n",

empty_pages),

empty_pages);

appendStringInfo(&buf,"%.0f tuples and %.0f item identifiers are left as dead.\n",

nleft_dead_tuples,nleft_dead_itemids);

appendStringInfo(&buf,_("%s."),pg_rusage_show(&ru0));

ereport(elevel,

autovacuum_work_mem!=-1 ?

autovacuum_work_mem :maintenance_work_mem;

if (vacrelstats->hasindex)

if (vacrelstats->useindex)

{

maxtuples= (vac_work_mem*1024L) /sizeof(ItemPointerData);

maxtuples=Min(maxtuples,INT_MAX);

TransactionIdlastSaneFrozenXid,

MultiXactIdlastSaneMinMulti);

staticboolvacuum_rel(Oidrelid,RangeVar*relation,VacuumParams*params);

staticVacOptTernaryValueget_vacopt_ternary_value(DefElem*def);

booldisable_page_skipping= false;

ListCell*lc;

params.index_cleanup=VACOPT_TERNARY_DEFAULT;

foreach(lc,vacstmt->options)

{

full=defGetBoolean(opt);

elseif (strcmp(opt->defname,"disable_page_skipping")==0)

disable_page_skipping=defGetBoolean(opt);

elseif (strcmp(opt->defname,"index_cleanup")==0)

params.index_cleanup=get_vacopt_ternary_value(opt);

ereport(ERROR,

(errcode(ERRCODE_SYNTAX_ERROR),

onerelid=onerel->rd_lockInfo.lockRelId;

LockRelationIdForSession(&onerelid,lmode);

if (params->index_cleanup==VACOPT_TERNARY_DEFAULT)

{

if (onerel->rd_options==NULL||

((StdRdOptions*)onerel->rd_options)->vacuum_index_cleanup)

params->index_cleanup=VACOPT_TERNARY_ENABLED;

params->index_cleanup=VACOPT_TERNARY_DISABLED;

}

CHECK_FOR_INTERRUPTS();

}

}

get_vacopt_ternary_value(DefElem*def)

{

returndefGetBoolean(def) ?VACOPT_TERNARY_ENABLED :VACOPT_TERNARY_DISABLED;

}

(dovacuum ?VACOPT_VACUUM :0) |

(doanalyze ?VACOPT_ANALYZE :0) |

(!wraparound ?VACOPT_SKIP_LOCKED :0);

tab->at_params.index_cleanup=VACOPT_TERNARY_DEFAULT;

tab->at_params.freeze_min_age=freeze_min_age;

tab->at_params.freeze_table_age=freeze_table_age;

tab->at_params.multixact_freeze_min_age=multixact_freeze_min_age;