open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Vacuum cleanup.

Browse Source
REL6_4
Bruce Momjian 28 years ago
parent bd5aaca391
commit a4d3695f28
1 changed files with 155 additions and 154 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 309
      src/backend/commands/vacuum.c

309
src/backend/commands/vacuum.c
Unescape View File

@ -7,7 +7,7 @@
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
@ -79,12 +79,12 @@ static void vc_shutdown(void);
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);
@ -373,9 +373,9 @@ vc_vacone(Oid relid, bool analyze, List *va_cols)
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;
@ -517,8 +517,8 @@ vc_vacone(Oid relid, bool analyze, List *va_cols)
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;
@ -532,10 +532,10 @@ vc_vacone(Oid relid, bool analyze, List *va_cols)
/* 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 */
@ -545,25 +545,25 @@ vc_vacone(Oid relid, bool analyze, List *va_cols)
}
}
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 */
@ -582,15 +582,15 @@ vc_vacone(Oid relid, bool analyze, List *va_cols)
/*
* 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;
@ -616,9 +616,9 @@ vc_scanheap(VRelStats *vacrelstats, Relation onerel,
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;
@ -628,8 +628,9 @@ vc_scanheap(VRelStats *vacrelstats, Relation onerel,
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;
@ -653,10 +654,10 @@ vc_scanheap(VRelStats *vacrelstats, Relation onerel,
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;
}
@ -664,10 +665,10 @@ vc_scanheap(VRelStats *vacrelstats, Relation onerel,
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;
}
@ -836,23 +837,23 @@ vc_scanheap(VRelStats *vacrelstats, Relation onerel,
{ /* 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);
@ -866,28 +867,28 @@ vc_scanheap(VRelStats *vacrelstats, Relation onerel,
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;
}
}
}
@ -896,9 +897,9 @@ vc_scanheap(VRelStats *vacrelstats, Relation onerel,
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);
@ -917,12 +918,12 @@ Tup %u: Vac %u, Crash %u, UnUsed %u, MinLen %u, MaxLen %u; Re-using: Free/Avail.
*/
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,
@ -940,21 +941,21 @@ vc_rpfheap(VRelStats *vacrelstats, Relation onerel,
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,
@ -976,25 +977,25 @@ vc_rpfheap(VRelStats *vacrelstats, Relation onerel,
}
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);
@ -1005,31 +1006,31 @@ vc_rpfheap(VRelStats *vacrelstats, Relation onerel,
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);
@ -1051,54 +1052,54 @@ vc_rpfheap(VRelStats *vacrelstats, Relation onerel,
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));
@ -1109,19 +1110,19 @@ vc_rpfheap(VRelStats *vacrelstats, Relation onerel,
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));
@ -1129,9 +1130,9 @@ failed to add item with len = %u to page %u (free space %u, nusd %u, noff %u)",
/* 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 */
@ -1177,13 +1178,13 @@ failed to add item with len = %u to page %u (free space %u, nusd %u, noff %u)",
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)
{
/*
@ -1198,11 +1199,11 @@ failed to add item with len = %u to page %u (free space %u, nusd %u, noff %u)",
}
/*
* 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);
@ -1241,14 +1242,14 @@ failed to add item with len = %u to page %u (free space %u, nusd %u, noff %u)",
}
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);
@ -1339,7 +1340,7 @@ Elapsed %u/%u 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;
@ -1347,10 +1348,10 @@ vc_vacheap(VRelStats *vacrelstats, Relation onerel, VPageList Vvpl)
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)
{
@ -1362,10 +1363,10 @@ vc_vacheap(VRelStats *vacrelstats, Relation onerel, VPageList Vvpl)
}
/* 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);
@ -1412,7 +1413,7 @@ vc_vacpage(Page page, VPageDescr vpd)
*
*/
static void
vc_scanoneind(Relation indrel, int nhtups)
vc_scanoneind(Relation indrel, int num_tuples)
{
RetrieveIndexResult res;
IndexScanDesc iscan;
@ -1447,9 +1448,9 @@ vc_scanoneind(Relation indrel, int nhtups)
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 */
@ -1466,14 +1467,14 @@ vc_scanoneind(Relation indrel, int nhtups)
* 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;
@ -1483,7 +1484,7 @@ vc_vaconeind(VPageList vpl, Relation indrel, int nhtups)
/* 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)
@ -1509,7 +1510,7 @@ vc_vaconeind(VPageList vpl, Relation indrel, int nhtups)
index_delete(indrel, &res->index_iptr);
}
else
nitups++;
num_index_tuples++;
pfree(res);
}
@ -1517,19 +1518,19 @@ vc_vaconeind(VPageList vpl, Relation indrel, int nhtups)
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 */

Write Preview
Loading…
Cancel
Save