*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.72 1998/08/19 19:59:43 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.73 1998/08/19 22:01:18 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static void vc_vacuum(NameData *VacRelP, bool analyze, List *va_cols);
static VRelList vc_getrels(NameData *VacRelP);
static void vc_vacone(Oid relid, bool analyze, List *va_cols);
-static void vc_scanheap(VRelStats *vacrelstats, Relation onerel, VPageList Vvpl, VPageList Fvpl);
-static void vc_rpfheap(VRelStats *vacrelstats, Relation onerel, VPageList Vvpl, VPageList Fvpl, int nindices, Relation *Irel);
+static void vc_scanheap(VRelStats *vacrelstats, Relation onerel, VPageList vacuum_pages, VPageList fraged_pages);
+static void vc_rpfheap(VRelStats *vacrelstats, Relation onerel, VPageList vacuum_pages, VPageList fraged_pages, int nindices, Relation *Irel);
static void vc_vacheap(VRelStats *vacrelstats, Relation onerel, VPageList vpl);
static void vc_vacpage(Page page, VPageDescr vpd);
-static void vc_vaconeind(VPageList vpl, Relation indrel, int nhtups);
-static void vc_scanoneind(Relation indrel, int nhtups);
+static void vc_vaconeind(VPageList vpl, Relation indrel, int num_tuples);
+static void vc_scanoneind(Relation indrel, int num_tuples);
static void vc_attrstats(Relation onerel, VRelStats *vacrelstats, HeapTuple tuple);
static void vc_bucketcpy(AttributeTupleForm attr, Datum value, Datum *bucket, int16 *bucket_len);
static void vc_updstats(Oid relid, int num_pages, int num_tuples, bool hasindex, VRelStats *vacrelstats);
HeapTuple tuple,
typetuple;
Relation onerel;
- VPageListData Vvpl; /* List of pages to vacuum and/or clean
+ VPageListData vacuum_pages; /* List of pages to vacuum and/or clean
* indices */
- VPageListData Fvpl; /* List of pages with space enough for
+ VPageListData fraged_pages; /* List of pages with space enough for
* re-using */
VPageDescr *vpp;
Relation *Irel;
RelationSetLockForWrite(onerel);
/* scan it */
- Vvpl.vpl_num_pages = Fvpl.vpl_num_pages = 0;
- vc_scanheap(vacrelstats, onerel, &Vvpl, &Fvpl);
+ vacuum_pages.vpl_num_pages = fraged_pages.vpl_num_pages = 0;
+ vc_scanheap(vacrelstats, onerel, &vacuum_pages, &fraged_pages);
/* Now open indices */
Irel = (Relation *) NULL;
/* Clean/scan index relation(s) */
if (Irel != (Relation *) NULL)
{
- if (Vvpl.vpl_num_pages > 0)
+ if (vacuum_pages.vpl_num_pages > 0)
{
for (i = 0; i < nindices; i++)
- vc_vaconeind(&Vvpl, Irel[i], vacrelstats->num_tuples);
+ vc_vaconeind(&vacuum_pages, Irel[i], vacrelstats->num_tuples);
}
else
/* just scan indices to update statistic */
}
}
- if (Fvpl.vpl_num_pages > 0) /* Try to shrink heap */
- vc_rpfheap(vacrelstats, onerel, &Vvpl, &Fvpl, nindices, Irel);
+ if (fraged_pages.vpl_num_pages > 0) /* Try to shrink heap */
+ vc_rpfheap(vacrelstats, onerel, &vacuum_pages, &fraged_pages, nindices, Irel);
else
{
if (Irel != (Relation *) NULL)
vc_clsindices(nindices, Irel);
- if (Vvpl.vpl_num_pages > 0)/* Clean pages from Vvpl list */
- vc_vacheap(vacrelstats, onerel, &Vvpl);
+ if (vacuum_pages.vpl_num_pages > 0)/* Clean pages from vacuum_pages list */
+ vc_vacheap(vacrelstats, onerel, &vacuum_pages);
}
- /* ok - free Vvpl list of reapped pages */
- if (Vvpl.vpl_num_pages > 0)
+ /* ok - free vacuum_pages list of reapped pages */
+ if (vacuum_pages.vpl_num_pages > 0)
{
- vpp = Vvpl.vpl_pagedesc;
- for (i = 0; i < Vvpl.vpl_num_pages; i++, vpp++)
+ vpp = vacuum_pages.vpl_pagedesc;
+ for (i = 0; i < vacuum_pages.vpl_num_pages; i++, vpp++)
pfree(*vpp);
- pfree(Vvpl.vpl_pagedesc);
- if (Fvpl.vpl_num_pages > 0)
- pfree(Fvpl.vpl_pagedesc);
+ pfree(vacuum_pages.vpl_pagedesc);
+ if (fraged_pages.vpl_num_pages > 0)
+ pfree(fraged_pages.vpl_pagedesc);
}
/* all done with this class */
/*
* vc_scanheap() -- scan an open heap relation
*
- * This routine sets commit times, constructs Vvpl list of
+ * This routine sets commit times, constructs vacuum_pages list of
* empty/uninitialized pages and pages with dead tuples and
- * ~LP_USED line pointers, constructs Fvpl list of pages
+ * ~LP_USED line pointers, constructs fraged_pages list of pages
* appropriate for purposes of shrinking and maintains statistics
* on the number of live tuples in a heap.
*/
static void
vc_scanheap(VRelStats *vacrelstats, Relation onerel,
- VPageList Vvpl, VPageList Fvpl)
+ VPageList vacuum_pages, VPageList fraged_pages)
{
int nblocks,
blkno;
empty_pages,
new_pages,
changed_pages,
- nemend;
- Size frsize,
- frsusf;
+ empty_end_pages;
+ Size free_size,
+ usable_free_size;
Size min_tlen = MAXTUPLEN;
Size max_tlen = 0;
int32 i;
getrusage(RUSAGE_SELF, &ru0);
- tups_vacuumed = num_tuples = nunused = ncrash = empty_pages = new_pages = changed_pages = nemend = 0;
- frsize = frsusf = 0;
+ tups_vacuumed = num_tuples = nunused = ncrash = empty_pages =
+ new_pages = changed_pages = empty_end_pages = 0;
+ free_size = usable_free_size = 0;
relname = (RelationGetRelationName(onerel))->data;
relname, blkno);
PageInit(page, BufferGetPageSize(buf), 0);
vpc->vpd_free = ((PageHeader) page)->pd_upper - ((PageHeader) page)->pd_lower;
- frsize += (vpc->vpd_free - sizeof(ItemIdData));
+ free_size += (vpc->vpd_free - sizeof(ItemIdData));
new_pages++;
- nemend++;
- vc_reappage(Vvpl, vpc);
+ empty_end_pages++;
+ vc_reappage(vacuum_pages, vpc);
WriteBuffer(buf);
continue;
}
if (PageIsEmpty(page))
{
vpc->vpd_free = ((PageHeader) page)->pd_upper - ((PageHeader) page)->pd_lower;
- frsize += (vpc->vpd_free - sizeof(ItemIdData));
+ free_size += (vpc->vpd_free - sizeof(ItemIdData));
empty_pages++;
- nemend++;
- vc_reappage(Vvpl, vpc);
+ empty_end_pages++;
+ vc_reappage(vacuum_pages, vpc);
ReleaseBuffer(buf);
continue;
}
{ /* Some tuples are gone */
PageRepairFragmentation(tempPage);
vpc->vpd_free = ((PageHeader) tempPage)->pd_upper - ((PageHeader) tempPage)->pd_lower;
- frsize += vpc->vpd_free;
- vc_reappage(Vvpl, vpc);
+ free_size += vpc->vpd_free;
+ vc_reappage(vacuum_pages, vpc);
pfree(tempPage);
tempPage = (Page) NULL;
}
else if (vpc->vpd_offsets_free > 0)
{ /* there are only ~LP_USED line pointers */
vpc->vpd_free = ((PageHeader) page)->pd_upper - ((PageHeader) page)->pd_lower;
- frsize += vpc->vpd_free;
- vc_reappage(Vvpl, vpc);
+ free_size += vpc->vpd_free;
+ vc_reappage(vacuum_pages, vpc);
}
if (dobufrel)
ReleaseBuffer(buf);
if (notup)
- nemend++;
+ empty_end_pages++;
else
- nemend = 0;
+ empty_end_pages = 0;
}
pfree(vpc);
vacrelstats->min_tlen = min_tlen;
vacrelstats->max_tlen = max_tlen;
- Vvpl->vpl_empty_end_pages = nemend;
- Fvpl->vpl_empty_end_pages = nemend;
+ vacuum_pages->vpl_empty_end_pages = empty_end_pages;
+ fraged_pages->vpl_empty_end_pages = empty_end_pages;
/*
- * Try to make Fvpl keeping in mind that we can't use free space of
+ * Try to make fraged_pages keeping in mind that we can't use free space of
* "empty" end-pages and last page if it reapped.
*/
- if (do_shrinking && Vvpl->vpl_num_pages - nemend > 0)
+ if (do_shrinking && vacuum_pages->vpl_num_pages - empty_end_pages > 0)
{
int nusf; /* blocks usefull for re-using */
- nusf = Vvpl->vpl_num_pages - nemend;
- if ((Vvpl->vpl_pagedesc[nusf - 1])->vpd_blkno == nblocks - nemend - 1)
+ nusf = vacuum_pages->vpl_num_pages - empty_end_pages;
+ if ((vacuum_pages->vpl_pagedesc[nusf - 1])->vpd_blkno == nblocks - empty_end_pages - 1)
nusf--;
for (i = 0; i < nusf; i++)
{
- vp = Vvpl->vpl_pagedesc[i];
+ vp = vacuum_pages->vpl_pagedesc[i];
if (vc_enough_space(vp, min_tlen))
{
- vc_vpinsert(Fvpl, vp);
- frsusf += vp->vpd_free;
+ vc_vpinsert(fraged_pages, vp);
+ usable_free_size += vp->vpd_free;
}
}
}
elog(MESSAGE_LEVEL, "Pages %u: Changed %u, Reapped %u, Empty %u, New %u; \
Tup %u: Vac %u, Crash %u, UnUsed %u, MinLen %u, MaxLen %u; Re-using: Free/Avail. Space %u/%u; EndEmpty/Avail. Pages %u/%u. Elapsed %u/%u sec.",
- nblocks, changed_pages, Vvpl->vpl_num_pages, empty_pages, new_pages,
+ nblocks, changed_pages, vacuum_pages->vpl_num_pages, empty_pages, new_pages,
num_tuples, tups_vacuumed, ncrash, nunused, min_tlen, max_tlen,
- frsize, frsusf, nemend, Fvpl->vpl_num_pages,
+ free_size, usable_free_size, empty_end_pages, fraged_pages->vpl_num_pages,
ru1.ru_stime.tv_sec - ru0.ru_stime.tv_sec,
ru1.ru_utime.tv_sec - ru0.ru_utime.tv_sec);
*/
static void
vc_rpfheap(VRelStats *vacrelstats, Relation onerel,
- VPageList Vvpl, VPageList Fvpl, int nindices, Relation *Irel)
+ VPageList vacuum_pages, VPageList fraged_pages, int nindices, Relation *Irel)
{
TransactionId myXID;
CommandId myCID;
Buffer buf,
- ToBuf;
+ cur_buffer;
int nblocks,
blkno;
Page page,
char *inulls = NULL;
InsertIndexResult iresult;
VPageListData Nvpl;
- VPageDescr ToVpd = NULL,
- Fvplast,
- Vvplast,
+ VPageDescr cur_page = NULL,
+ last_fraged_page,
+ last_vacuum_page,
vpc,
*vpp;
- int ToVpI = 0;
+ int cur_item = 0;
IndDesc *Idesc,
*idcur;
- int Fblklast,
- Vblklast,
+ int last_fraged_block,
+ last_vacuum_block,
i;
- Size tlen;
- int nmoved,
- Fnum_pages,
- Vnum_pages;
+ Size tuple_len;
+ int num_moved,
+ num_fraged_pages,
+ vacuumed_pages;
int checked_moved,
num_tuples;
bool isempty,
}
Nvpl.vpl_num_pages = 0;
- Fnum_pages = Fvpl->vpl_num_pages;
- Fvplast = Fvpl->vpl_pagedesc[Fnum_pages - 1];
- Fblklast = Fvplast->vpd_blkno;
- Assert(Vvpl->vpl_num_pages > Vvpl->vpl_empty_end_pages);
- Vnum_pages = Vvpl->vpl_num_pages - Vvpl->vpl_empty_end_pages;
- Vvplast = Vvpl->vpl_pagedesc[Vnum_pages - 1];
- Vblklast = Vvplast->vpd_blkno;
- Assert(Vblklast >= Fblklast);
- ToBuf = InvalidBuffer;
- nmoved = 0;
+ num_fraged_pages = fraged_pages->vpl_num_pages;
+ last_fraged_page = fraged_pages->vpl_pagedesc[num_fraged_pages - 1];
+ last_fraged_block = last_fraged_page->vpd_blkno;
+ Assert(vacuum_pages->vpl_num_pages > vacuum_pages->vpl_empty_end_pages);
+ vacuumed_pages = vacuum_pages->vpl_num_pages - vacuum_pages->vpl_empty_end_pages;
+ last_vacuum_page = vacuum_pages->vpl_pagedesc[vacuumed_pages - 1];
+ last_vacuum_block = last_vacuum_page->vpd_blkno;
+ Assert(last_vacuum_block >= last_fraged_block);
+ cur_buffer = InvalidBuffer;
+ num_moved = 0;
vpc = (VPageDescr) palloc(sizeof(VPageDescrData) + MaxOffsetNumber * sizeof(OffsetNumber));
vpc->vpd_offsets_used = vpc->vpd_offsets_free = 0;
nblocks = vacrelstats->num_pages;
- for (blkno = nblocks - Vvpl->vpl_empty_end_pages - 1;; blkno--)
+ for (blkno = nblocks - vacuum_pages->vpl_empty_end_pages - 1;; blkno--)
{
/* if it's reapped page and it was used by me - quit */
- if (blkno == Fblklast && Fvplast->vpd_offsets_used > 0)
+ if (blkno == last_fraged_block && last_fraged_page->vpd_offsets_used > 0)
break;
buf = ReadBuffer(onerel, blkno);
isempty = PageIsEmpty(page);
dowrite = false;
- if (blkno == Vblklast) /* it's reapped page */
+ if (blkno == last_vacuum_block) /* it's reapped page */
{
- if (Vvplast->vpd_offsets_free > 0) /* there are dead tuples */
+ if (last_vacuum_page->vpd_offsets_free > 0) /* there are dead tuples */
{ /* on this page - clean */
Assert(!isempty);
- vc_vacpage(page, Vvplast);
+ vc_vacpage(page, last_vacuum_page);
dowrite = true;
}
else
Assert(isempty);
- --Vnum_pages;
- Assert(Vnum_pages > 0);
- /* get prev reapped page from Vvpl */
- Vvplast = Vvpl->vpl_pagedesc[Vnum_pages - 1];
- Vblklast = Vvplast->vpd_blkno;
- if (blkno == Fblklast) /* this page in Fvpl too */
+ --vacuumed_pages;
+ Assert(vacuumed_pages > 0);
+ /* get prev reapped page from vacuum_pages */
+ last_vacuum_page = vacuum_pages->vpl_pagedesc[vacuumed_pages - 1];
+ last_vacuum_block = last_vacuum_page->vpd_blkno;
+ if (blkno == last_fraged_block) /* this page in fraged_pages too */
{
- --Fnum_pages;
- Assert(Fnum_pages > 0);
- Assert(Fvplast->vpd_offsets_used == 0);
- /* get prev reapped page from Fvpl */
- Fvplast = Fvpl->vpl_pagedesc[Fnum_pages - 1];
- Fblklast = Fvplast->vpd_blkno;
+ --num_fraged_pages;
+ Assert(num_fraged_pages > 0);
+ Assert(last_fraged_page->vpd_offsets_used == 0);
+ /* get prev reapped page from fraged_pages */
+ last_fraged_page = fraged_pages->vpl_pagedesc[num_fraged_pages - 1];
+ last_fraged_block = last_fraged_page->vpd_blkno;
}
- Assert(Fblklast <= Vblklast);
+ Assert(last_fraged_block <= last_vacuum_block);
if (isempty)
{
ReleaseBuffer(buf);
continue;
tuple = (HeapTuple) PageGetItem(page, itemid);
- tlen = tuple->t_len;
+ tuple_len = tuple->t_len;
/* try to find new page for this tuple */
- if (ToBuf == InvalidBuffer ||
- !vc_enough_space(ToVpd, tlen))
+ if (cur_buffer == InvalidBuffer ||
+ !vc_enough_space(cur_page, tuple_len))
{
- if (ToBuf != InvalidBuffer)
+ if (cur_buffer != InvalidBuffer)
{
- WriteBuffer(ToBuf);
- ToBuf = InvalidBuffer;
+ WriteBuffer(cur_buffer);
+ cur_buffer = InvalidBuffer;
/*
* If no one tuple can't be added to this page -
- * remove page from Fvpl. - vadim 11/27/96
+ * remove page from fraged_pages. - vadim 11/27/96
*
* But we can't remove last page - this is our
* "show-stopper" !!! - vadim 02/25/98
*/
- if (ToVpd != Fvplast &&
- !vc_enough_space(ToVpd, vacrelstats->min_tlen))
+ if (cur_page != last_fraged_page &&
+ !vc_enough_space(cur_page, vacrelstats->min_tlen))
{
- Assert(Fnum_pages > ToVpI + 1);
- memmove(Fvpl->vpl_pagedesc + ToVpI,
- Fvpl->vpl_pagedesc + ToVpI + 1,
- sizeof(VPageDescr *) * (Fnum_pages - ToVpI - 1));
- Fnum_pages--;
- Assert(Fvplast == Fvpl->vpl_pagedesc[Fnum_pages - 1]);
+ Assert(num_fraged_pages > cur_item + 1);
+ memmove(fraged_pages->vpl_pagedesc + cur_item,
+ fraged_pages->vpl_pagedesc + cur_item + 1,
+ sizeof(VPageDescr *) * (num_fraged_pages - cur_item - 1));
+ num_fraged_pages--;
+ Assert(last_fraged_page == fraged_pages->vpl_pagedesc[num_fraged_pages - 1]);
}
}
- for (i = 0; i < Fnum_pages; i++)
+ for (i = 0; i < num_fraged_pages; i++)
{
- if (vc_enough_space(Fvpl->vpl_pagedesc[i], tlen))
+ if (vc_enough_space(fraged_pages->vpl_pagedesc[i], tuple_len))
break;
}
- if (i == Fnum_pages)
+ if (i == num_fraged_pages)
break; /* can't move item anywhere */
- ToVpI = i;
- ToVpd = Fvpl->vpl_pagedesc[ToVpI];
- ToBuf = ReadBuffer(onerel, ToVpd->vpd_blkno);
- ToPage = BufferGetPage(ToBuf);
+ cur_item = i;
+ cur_page = fraged_pages->vpl_pagedesc[cur_item];
+ cur_buffer = ReadBuffer(onerel, cur_page->vpd_blkno);
+ ToPage = BufferGetPage(cur_buffer);
/* if this page was not used before - clean it */
- if (!PageIsEmpty(ToPage) && ToVpd->vpd_offsets_used == 0)
- vc_vacpage(ToPage, ToVpd);
+ if (!PageIsEmpty(ToPage) && cur_page->vpd_offsets_used == 0)
+ vc_vacpage(ToPage, cur_page);
}
/* copy tuple */
- newtup = (HeapTuple) palloc(tlen);
- memmove((char *) newtup, (char *) tuple, tlen);
+ newtup = (HeapTuple) palloc(tuple_len);
+ memmove((char *) newtup, (char *) tuple, tuple_len);
/* store transaction information */
TransactionIdStore(myXID, &(newtup->t_xmin));
newtup->t_infomask |= HEAP_XMAX_INVALID;
/* add tuple to the page */
- newoff = PageAddItem(ToPage, (Item) newtup, tlen,
+ newoff = PageAddItem(ToPage, (Item) newtup, tuple_len,
InvalidOffsetNumber, LP_USED);
if (newoff == InvalidOffsetNumber)
{
elog(ERROR, "\
failed to add item with len = %u to page %u (free space %u, nusd %u, noff %u)",
- tlen, ToVpd->vpd_blkno, ToVpd->vpd_free,
- ToVpd->vpd_offsets_used, ToVpd->vpd_offsets_free);
+ tuple_len, cur_page->vpd_blkno, cur_page->vpd_free,
+ cur_page->vpd_offsets_used, cur_page->vpd_offsets_free);
}
newitemid = PageGetItemId(ToPage, newoff);
pfree(newtup);
newtup = (HeapTuple) PageGetItem(ToPage, newitemid);
- ItemPointerSet(&(newtup->t_ctid), ToVpd->vpd_blkno, newoff);
+ ItemPointerSet(&(newtup->t_ctid), cur_page->vpd_blkno, newoff);
/* now logically delete end-tuple */
TransactionIdStore(myXID, &(tuple->t_xmax));
/* set xmax to unknown */
tuple->t_infomask &= ~(HEAP_XMAX_INVALID | HEAP_XMAX_COMMITTED);
- ToVpd->vpd_offsets_used++;
- nmoved++;
- ToVpd->vpd_free = ((PageHeader) ToPage)->pd_upper - ((PageHeader) ToPage)->pd_lower;
+ cur_page->vpd_offsets_used++;
+ num_moved++;
+ cur_page->vpd_free = ((PageHeader) ToPage)->pd_upper - ((PageHeader) ToPage)->pd_lower;
vpc->vpd_offsets[vpc->vpd_offsets_free++] = offnum;
/* insert index' tuples if needed */
blkno++; /* new number of blocks */
- if (ToBuf != InvalidBuffer)
+ if (cur_buffer != InvalidBuffer)
{
- Assert(nmoved > 0);
- WriteBuffer(ToBuf);
+ Assert(num_moved > 0);
+ WriteBuffer(cur_buffer);
}
- if (nmoved > 0)
+ if (num_moved > 0)
{
/*
}
/*
- * Clean uncleaned reapped pages from Vvpl list and set xmin committed
+ * Clean uncleaned reapped pages from vacuum_pages list and set xmin committed
* for inserted tuples
*/
checked_moved = 0;
- for (i = 0, vpp = Vvpl->vpl_pagedesc; i < Vnum_pages; i++, vpp++)
+ for (i = 0, vpp = vacuum_pages->vpl_pagedesc; i < vacuumed_pages; i++, vpp++)
{
Assert((*vpp)->vpd_blkno < blkno);
buf = ReadBuffer(onerel, (*vpp)->vpd_blkno);
}
WriteBuffer(buf);
}
- Assert(nmoved == checked_moved);
+ Assert(num_moved == checked_moved);
getrusage(RUSAGE_SELF, &ru1);
elog(MESSAGE_LEVEL, "Rel %s: Pages: %u --> %u; Tuple(s) moved: %u. \
Elapsed %u/%u sec.",
(RelationGetRelationName(onerel))->data,
- nblocks, blkno, nmoved,
+ nblocks, blkno, num_moved,
ru1.ru_stime.tv_sec - ru0.ru_stime.tv_sec,
ru1.ru_utime.tv_sec - ru0.ru_utime.tv_sec);
* if there are "empty" end-blocks.
*/
static void
-vc_vacheap(VRelStats *vacrelstats, Relation onerel, VPageList Vvpl)
+vc_vacheap(VRelStats *vacrelstats, Relation onerel, VPageList vacuum_pages)
{
Buffer buf;
Page page;
int nblocks;
int i;
- nblocks = Vvpl->vpl_num_pages;
- nblocks -= Vvpl->vpl_empty_end_pages;/* nothing to do with them */
+ nblocks = vacuum_pages->vpl_num_pages;
+ nblocks -= vacuum_pages->vpl_empty_end_pages;/* nothing to do with them */
- for (i = 0, vpp = Vvpl->vpl_pagedesc; i < nblocks; i++, vpp++)
+ for (i = 0, vpp = vacuum_pages->vpl_pagedesc; i < nblocks; i++, vpp++)
{
if ((*vpp)->vpd_offsets_free > 0)
{
}
/* truncate relation if there are some empty end-pages */
- if (Vvpl->vpl_empty_end_pages > 0)
+ if (vacuum_pages->vpl_empty_end_pages > 0)
{
- Assert(vacrelstats->num_pages >= Vvpl->vpl_empty_end_pages);
- nblocks = vacrelstats->num_pages - Vvpl->vpl_empty_end_pages;
+ Assert(vacrelstats->num_pages >= vacuum_pages->vpl_empty_end_pages);
+ nblocks = vacrelstats->num_pages - vacuum_pages->vpl_empty_end_pages;
elog(MESSAGE_LEVEL, "Rel %s: Pages: %u --> %u.",
(RelationGetRelationName(onerel))->data,
vacrelstats->num_pages, nblocks);
*
*/
static void
-vc_scanoneind(Relation indrel, int nhtups)
+vc_scanoneind(Relation indrel, int num_tuples)
{
RetrieveIndexResult res;
IndexScanDesc iscan;
ru1.ru_stime.tv_sec - ru0.ru_stime.tv_sec,
ru1.ru_utime.tv_sec - ru0.ru_utime.tv_sec);
- if (nitups != nhtups)
+ if (nitups != num_tuples)
elog(NOTICE, "Ind %s: NUMBER OF INDEX' TUPLES (%u) IS NOT THE SAME AS HEAP' (%u)",
- indrel->rd_rel->relname.data, nitups, nhtups);
+ indrel->rd_rel->relname.data, nitups, num_tuples);
} /* vc_scanoneind */
* pg_class.
*/
static void
-vc_vaconeind(VPageList vpl, Relation indrel, int nhtups)
+vc_vaconeind(VPageList vpl, Relation indrel, int num_tuples)
{
RetrieveIndexResult res;
IndexScanDesc iscan;
ItemPointer heapptr;
int tups_vacuumed;
- int nitups;
- int nipages;
+ int num_index_tuples;
+ int num_pages;
VPageDescr vp;
struct rusage ru0,
ru1;
/* walk through the entire index */
iscan = index_beginscan(indrel, false, 0, (ScanKey) NULL);
tups_vacuumed = 0;
- nitups = 0;
+ num_index_tuples = 0;
while ((res = index_getnext(iscan, ForwardScanDirection))
!= (RetrieveIndexResult) NULL)
index_delete(indrel, &res->index_iptr);
}
else
- nitups++;
+ num_index_tuples++;
pfree(res);
}
index_endscan(iscan);
/* now update statistics in pg_class */
- nipages = RelationGetNumberOfBlocks(indrel);
- vc_updstats(RelationGetRelid(indrel), nipages, nitups, false, NULL);
+ num_pages = RelationGetNumberOfBlocks(indrel);
+ vc_updstats(RelationGetRelid(indrel), num_pages, num_index_tuples, false, NULL);
getrusage(RUSAGE_SELF, &ru1);
elog(MESSAGE_LEVEL, "Ind %s: Pages %u; Tuples %u: Deleted %u. Elapsed %u/%u sec.",
- indrel->rd_rel->relname.data, nipages, nitups, tups_vacuumed,
+ indrel->rd_rel->relname.data, num_pages, num_index_tuples, tups_vacuumed,
ru1.ru_stime.tv_sec - ru0.ru_stime.tv_sec,
ru1.ru_utime.tv_sec - ru0.ru_utime.tv_sec);
- if (nitups != nhtups)
+ if (num_index_tuples != num_tuples)
elog(NOTICE, "Ind %s: NUMBER OF INDEX' TUPLES (%u) IS NOT THE SAME AS HEAP' (%u)",
- indrel->rd_rel->relname.data, nitups, nhtups);
+ indrel->rd_rel->relname.data, num_index_tuples, num_tuples);
} /* vc_vaconeind */
projects / thirdparty / postgresql.git / commitdiff
