开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
vacuum.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：76k
源码类别：

数据库系统

开发平台：

Unix_Linux

vacuum.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * vacuum.c
  4.  *   the postgres vacuum cleaner
  5.  *
  6.  * Copyright (c) 1994, Regents of the University of California
  7.  *
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.110.2.3 1999/08/25 12:01:45 ishii Exp $
  11.  *
  12.  *-------------------------------------------------------------------------
  13.  */
  14. #include <sys/types.h>
  15. #include <sys/file.h>
  16. #include <sys/stat.h>
  17. #include <fcntl.h>
  18. #include <unistd.h>
  20. #include "postgres.h"
  22. #include "access/genam.h"
  23. #include "access/heapam.h"
  24. #include "catalog/catalog.h"
  25. #include "catalog/catname.h"
  26. #include "catalog/index.h"
  27. #include "catalog/pg_operator.h"
  28. #include "catalog/pg_statistic.h"
  29. #include "catalog/pg_type.h"
  30. #include "commands/vacuum.h"
  31. #include "miscadmin.h"
  32. #include "parser/parse_oper.h"
  33. #include "storage/smgr.h"
  34. #include "utils/builtins.h"
  35. #include "utils/inval.h"
  36. #include "utils/portal.h"
  37. #include "utils/relcache.h"
  38. #include "utils/syscache.h"
  40. #ifndef HAVE_GETRUSAGE
  41. #include "rusagestub.h"
  42. #else
  43. #include <sys/time.h>
  44. #include <sys/resource.h>
  45. #endif
  47.  /* #include <port-protos.h> *//* Why? */
  49. extern int BlowawayRelationBuffers(Relation rel, BlockNumber block);
  51. bool VacuumRunning = false;
  53. static Portal vc_portal;
  55. static int MESSAGE_LEVEL; /* message level */
  57. static TransactionId XmaxRecent;
  59. #define swapLong(a,b) {long tmp; tmp=a; a=b; b=tmp;}
  60. #define swapInt(a,b) {int tmp; tmp=a; a=b; b=tmp;}
  61. #define swapDatum(a,b) {Datum tmp; tmp=a; a=b; b=tmp;}
  62. #define VacAttrStatsEqValid(stats) ( stats->f_cmpeq.fn_addr != NULL )
  63. #define VacAttrStatsLtGtValid(stats) ( stats->f_cmplt.fn_addr != NULL && 
  64.    stats->f_cmpgt.fn_addr != NULL && 
  65.    RegProcedureIsValid(stats->outfunc) )
  68. /* non-export function prototypes */
  69. static void vc_init(void);
  70. static void vc_shutdown(void);
  71. static void vc_vacuum(NameData *VacRelP, bool analyze, List *va_cols);
  72. static VRelList vc_getrels(NameData *VacRelP);
  73. static void vc_vacone(Oid relid, bool analyze, List *va_cols);
  74. static void vc_scanheap(VRelStats *vacrelstats, Relation onerel, VPageList vacuum_pages, VPageList fraged_pages);
  75. static void vc_rpfheap(VRelStats *vacrelstats, Relation onerel, VPageList vacuum_pages, VPageList fraged_pages, int nindices, Relation *Irel);
  76. static void vc_vacheap(VRelStats *vacrelstats, Relation onerel, VPageList vpl);
  77. static void vc_vacpage(Page page, VPageDescr vpd);
  78. static void vc_vaconeind(VPageList vpl, Relation indrel, int num_tuples, int keep_tuples);
  79. static void vc_scanoneind(Relation indrel, int num_tuples);
  80. static void vc_attrstats(Relation onerel, VRelStats *vacrelstats, HeapTuple tuple);
  81. static void vc_bucketcpy(Form_pg_attribute attr, Datum value, Datum *bucket, int16 *bucket_len);
  82. static void vc_updstats(Oid relid, int num_pages, int num_tuples, bool hasindex, VRelStats *vacrelstats);
  83. static void vc_delhilowstats(Oid relid, int attcnt, int *attnums);
  84. static VPageDescr vc_tidreapped(ItemPointer itemptr, VPageList vpl);
  85. static void vc_reappage(VPageList vpl, VPageDescr vpc);
  86. static void vc_vpinsert(VPageList vpl, VPageDescr vpnew);
  87. static void vc_free(VRelList vrl);
  88. static void vc_getindices(Oid relid, int *nindices, Relation **Irel);
  89. static void vc_clsindices(int nindices, Relation *Irel);
  90. static void vc_mkindesc(Relation onerel, int nindices, Relation *Irel, IndDesc **Idesc);
  91. static void *vc_find_eq(void *bot, int nelem, int size, void *elm,
  92.    int (*compar) (const void *, const void *));
  93. static int vc_cmp_blk(const void *left, const void *right);
  94. static int vc_cmp_offno(const void *left, const void *right);
  95. static int vc_cmp_vtlinks(const void *left, const void *right);
  96. static bool vc_enough_space(VPageDescr vpd, Size len);
  98. void
  99. vacuum(char *vacrel, bool verbose, bool analyze, List *va_spec)
  100. {
  101. char    *pname;
  102. MemoryContext old;
  103. PortalVariableMemory pmem;
  104. NameData VacRel;
  105. List    *le;
  106. List    *va_cols = NIL;
  108. /*
  109.  * Create a portal for safe memory across transctions. We need to
  110.  * palloc the name space for it because our hash function expects the
  111.  * name to be on a longword boundary.  CreatePortal copies the name to
  112.  * safe storage for us.
  113.  */
  114. pname = (char *) palloc(strlen(VACPNAME) + 1);
  115. strcpy(pname, VACPNAME);
  116. vc_portal = CreatePortal(pname);
  117. pfree(pname);
  119. if (verbose)
  120. MESSAGE_LEVEL = NOTICE;
  121. else
  122. MESSAGE_LEVEL = DEBUG;
  124. /* vacrel gets de-allocated on transaction commit */
  125. if (vacrel)
  126. strcpy(VacRel.data, vacrel);
  128. pmem = PortalGetVariableMemory(vc_portal);
  129. old = MemoryContextSwitchTo((MemoryContext) pmem);
  131. if (va_spec != NIL && !analyze)
  132. elog(ERROR, "Can't vacuum columns, only tables.  You can 'vacuum analyze' columns.");
  134. foreach(le, va_spec)
  135. {
  136. char    *col = (char *) lfirst(le);
  137. char    *dest;
  139. dest = (char *) palloc(strlen(col) + 1);
  140. strcpy(dest, col);
  141. va_cols = lappend(va_cols, dest);
  142. }
  143. MemoryContextSwitchTo(old);
  145. /* initialize vacuum cleaner */
  146. vc_init();
  148. /* vacuum the database */
  149. if (vacrel)
  150. vc_vacuum(&VacRel, analyze, va_cols);
  151. else
  152. vc_vacuum(NULL, analyze, NIL);
  154. PortalDestroy(&vc_portal);
  156. /* clean up */
  157. vc_shutdown();
  158. }
  160. /*
  161.  * vc_init(), vc_shutdown() -- start up and shut down the vacuum cleaner.
  162.  *
  163.  * We run exactly one vacuum cleaner at a time.  We use the file system
  164.  * to guarantee an exclusive lock on vacuuming, since a single vacuum
  165.  * cleaner instantiation crosses transaction boundaries, and we'd lose
  166.  * postgres-style locks at the end of every transaction.
  167.  *
  168.  * The strangeness with committing and starting transactions in the
  169.  * init and shutdown routines is due to the fact that the vacuum cleaner
  170.  * is invoked via a sql command, and so is already executing inside
  171.  * a transaction. We need to leave ourselves in a predictable state
  172.  * on entry and exit to the vacuum cleaner.  We commit the transaction
  173.  * started in PostgresMain() inside vc_init(), and start one in
  174.  * vc_shutdown() to match the commit waiting for us back in
  175.  * PostgresMain().
  176.  */
  177. static void
  178. vc_init()
  179. {
  180. int fd;
  182. #ifndef __CYGWIN32__
  183. if ((fd = open("pg_vlock", O_CREAT | O_EXCL, 0600)) < 0)
  184. #else
  185. if ((fd = open("pg_vlock", O_CREAT | O_EXCL | O_BINARY, 0600)) < 0)
  186. #endif
  187. {
  188. elog(ERROR, "Can't create lock file.  Is another vacuum cleaner running?n
  189. tIf not, you may remove the pg_vlock file in the %sn
  190. tdirectory", DatabasePath);
  191. }
  192. close(fd);
  194. /*
  195.  * By here, exclusive open on the lock file succeeded. If we abort
  196.  * for any reason during vacuuming, we need to remove the lock file.
  197.  * This global variable is checked in the transaction manager on xact
  198.  * abort, and the routine vc_abort() is called if necessary.
  199.  */
  201. VacuumRunning = true;
  203. /* matches the StartTransaction in PostgresMain() */
  204. CommitTransactionCommand();
  205. }
  207. static void
  208. vc_shutdown()
  209. {
  210. /* on entry, we are not in a transaction */
  212. /*
  213.  * Flush the init file that relcache.c uses to save startup time. The
  214.  * next backend startup will rebuild the init file with up-to-date
  215.  * information from pg_class.  This lets the optimizer see the stats
  216.  * that we've collected for certain critical system indexes.  See
  217.  * relcache.c for more details.
  218.  *
  219.  * Ignore any failure to unlink the file, since it might not be there if
  220.  * no backend has been started since the last vacuum...
  221.  */
  222. unlink(RELCACHE_INIT_FILENAME);
  224. /* remove the vacuum cleaner lock file */
  225. if (unlink("pg_vlock") < 0)
  226. elog(ERROR, "vacuum: can't destroy lock file!");
  228. /* okay, we're done */
  229. VacuumRunning = false;
  231. /* matches the CommitTransaction in PostgresMain() */
  232. StartTransactionCommand();
  234. }
  236. void
  237. vc_abort()
  238. {
  239. /* on abort, remove the vacuum cleaner lock file */
  240. unlink("pg_vlock");
  242. VacuumRunning = false;
  243. }
  245. /*
  246.  * vc_vacuum() -- vacuum the database.
  247.  *
  248.  * This routine builds a list of relations to vacuum, and then calls
  249.  * code that vacuums them one at a time.  We are careful to vacuum each
  250.  * relation in a separate transaction in order to avoid holding too many
  251.  * locks at one time.
  252.  */
  253. static void
  254. vc_vacuum(NameData *VacRelP, bool analyze, List *va_cols)
  255. {
  256. VRelList vrl,
  257. cur;
  259. /* get list of relations */
  260. vrl = vc_getrels(VacRelP);
  262. if (analyze && VacRelP == NULL && vrl != NULL)
  263. vc_delhilowstats(InvalidOid, 0, NULL);
  265. /* vacuum each heap relation */
  266. for (cur = vrl; cur != (VRelList) NULL; cur = cur->vrl_next)
  267. vc_vacone(cur->vrl_relid, analyze, va_cols);
  269. vc_free(vrl);
  270. }
  272. static VRelList
  273. vc_getrels(NameData *VacRelP)
  274. {
  275. Relation rel;
  276. TupleDesc tupdesc;
  277. HeapScanDesc scan;
  278. HeapTuple tuple;
  279. PortalVariableMemory portalmem;
  280. MemoryContext old;
  281. VRelList vrl,
  282. cur;
  283. Datum d;
  284. char    *rname;
  285. char rkind;
  286. bool n;
  287. bool found = false;
  288. ScanKeyData key;
  290. StartTransactionCommand();
  292. if (VacRelP->data)
  293. {
  294. ScanKeyEntryInitialize(&key, 0x0, Anum_pg_class_relname,
  295.    F_NAMEEQ,
  296.    PointerGetDatum(VacRelP->data));
  297. }
  298. else
  299. {
  300. ScanKeyEntryInitialize(&key, 0x0, Anum_pg_class_relkind,
  301.    F_CHAREQ, CharGetDatum('r'));
  302. }
  304. portalmem = PortalGetVariableMemory(vc_portal);
  305. vrl = cur = (VRelList) NULL;
  307. rel = heap_openr(RelationRelationName);
  308. tupdesc = RelationGetDescr(rel);
  310. scan = heap_beginscan(rel, false, SnapshotNow, 1, &key);
  312. while (HeapTupleIsValid(tuple = heap_getnext(scan, 0)))
  313. {
  314. found = true;
  316. d = heap_getattr(tuple, Anum_pg_class_relname, tupdesc, &n);
  317. rname = (char *) d;
  319. d = heap_getattr(tuple, Anum_pg_class_relkind, tupdesc, &n);
  321. rkind = DatumGetChar(d);
  323. if (rkind != RELKIND_RELATION)
  324. {
  325. elog(NOTICE, "Vacuum: can not process index and certain system tables");
  326. continue;
  327. }
  329. /* get a relation list entry for this guy */
  330. old = MemoryContextSwitchTo((MemoryContext) portalmem);
  331. if (vrl == (VRelList) NULL)
  332. vrl = cur = (VRelList) palloc(sizeof(VRelListData));
  333. else
  334. {
  335. cur->vrl_next = (VRelList) palloc(sizeof(VRelListData));
  336. cur = cur->vrl_next;
  337. }
  338. MemoryContextSwitchTo(old);
  340. cur->vrl_relid = tuple->t_data->t_oid;
  341. cur->vrl_next = (VRelList) NULL;
  342. }
  343. if (found == false)
  344. elog(NOTICE, "Vacuum: table not found");
  347. heap_endscan(scan);
  348. heap_close(rel);
  350. CommitTransactionCommand();
  352. return vrl;
  353. }
  355. /*
  356.  * vc_vacone() -- vacuum one heap relation
  357.  *
  358.  * This routine vacuums a single heap, cleans out its indices, and
  359.  * updates its statistics num_pages and num_tuples statistics.
  360.  *
  361.  * Doing one heap at a time incurs extra overhead, since we need to
  362.  * check that the heap exists again just before we vacuum it. The
  363.  * reason that we do this is so that vacuuming can be spread across
  364.  * many small transactions.  Otherwise, two-phase locking would require
  365.  * us to lock the entire database during one pass of the vacuum cleaner.
  366.  */
  367. static void
  368. vc_vacone(Oid relid, bool analyze, List *va_cols)
  369. {
  370. HeapTuple tuple,
  371. typetuple;
  372. Relation onerel;
  373. VPageListData vacuum_pages; /* List of pages to vacuum and/or clean
  374.  * indices */
  375. VPageListData fraged_pages; /* List of pages with space enough for
  376.  * re-using */
  377. VPageDescr *vpp;
  378. Relation   *Irel;
  379. int32 nindices,
  380. i;
  381. VRelStats  *vacrelstats;
  383. StartTransactionCommand();
  385. /*
  386.  * Race condition -- if the pg_class tuple has gone away since the
  387.  * last time we saw it, we don't need to vacuum it.
  388.  */
  389. tuple = SearchSysCacheTuple(RELOID,
  390. ObjectIdGetDatum(relid),
  391. 0, 0, 0);
  392. if (!HeapTupleIsValid(tuple))
  393. {
  394. CommitTransactionCommand();
  395. return;
  396. }
  398. /* now open the class and vacuum it */
  399. onerel = heap_open(relid);
  401. vacrelstats = (VRelStats *) palloc(sizeof(VRelStats));
  402. vacrelstats->relid = relid;
  403. vacrelstats->num_pages = vacrelstats->num_tuples = 0;
  404. vacrelstats->hasindex = false;
  405. if (analyze && !IsSystemRelationName((RelationGetRelationName(onerel))->data))
  406. {
  407. int attr_cnt,
  408.    *attnums = NULL;
  409. Form_pg_attribute *attr;
  411. attr_cnt = onerel->rd_att->natts;
  412. attr = onerel->rd_att->attrs;
  414. if (va_cols != NIL)
  415. {
  416. int tcnt = 0;
  417. List    *le;
  419. if (length(va_cols) > attr_cnt)
  420. elog(ERROR, "vacuum: too many attributes specified for relation %s",
  421.  (RelationGetRelationName(onerel))->data);
  422. attnums = (int *) palloc(attr_cnt * sizeof(int));
  423. foreach(le, va_cols)
  424. {
  425. char    *col = (char *) lfirst(le);
  427. for (i = 0; i < attr_cnt; i++)
  428. {
  429. if (namestrcmp(&(attr[i]->attname), col) == 0)
  430. break;
  431. }
  432. if (i < attr_cnt) /* found */
  433. attnums[tcnt++] = i;
  434. else
  435. {
  436. elog(ERROR, "vacuum: there is no attribute %s in %s",
  437.  col, (RelationGetRelationName(onerel))->data);
  438. }
  439. }
  440. attr_cnt = tcnt;
  441. }
  443. vacrelstats->vacattrstats = (VacAttrStats *) palloc(attr_cnt * sizeof(VacAttrStats));
  445. for (i = 0; i < attr_cnt; i++)
  446. {
  447. Operator func_operator;
  448. Form_pg_operator pgopform;
  449. VacAttrStats *stats;
  451. stats = &vacrelstats->vacattrstats[i];
  452. stats->attr = palloc(ATTRIBUTE_TUPLE_SIZE);
  453. memmove(stats->attr, attr[((attnums) ? attnums[i] : i)], ATTRIBUTE_TUPLE_SIZE);
  454. stats->best = stats->guess1 = stats->guess2 = 0;
  455. stats->max = stats->min = 0;
  456. stats->best_len = stats->guess1_len = stats->guess2_len = 0;
  457. stats->max_len = stats->min_len = 0;
  458. stats->initialized = false;
  459. stats->best_cnt = stats->guess1_cnt = stats->guess1_hits = stats->guess2_hits = 0;
  460. stats->max_cnt = stats->min_cnt = stats->null_cnt = stats->nonnull_cnt = 0;
  462. func_operator = oper("=", stats->attr->atttypid, stats->attr->atttypid, true);
  463. if (func_operator != NULL)
  464. {
  465. pgopform = (Form_pg_operator) GETSTRUCT(func_operator);
  466. fmgr_info(pgopform->oprcode, &(stats->f_cmpeq));
  467. }
  468. else
  469. stats->f_cmpeq.fn_addr = NULL;
  471. func_operator = oper("<", stats->attr->atttypid, stats->attr->atttypid, true);
  472. if (func_operator != NULL)
  473. {
  474. pgopform = (Form_pg_operator) GETSTRUCT(func_operator);
  475. fmgr_info(pgopform->oprcode, &(stats->f_cmplt));
  476. }
  477. else
  478. stats->f_cmplt.fn_addr = NULL;
  480. func_operator = oper(">", stats->attr->atttypid, stats->attr->atttypid, true);
  481. if (func_operator != NULL)
  482. {
  483. pgopform = (Form_pg_operator) GETSTRUCT(func_operator);
  484. fmgr_info(pgopform->oprcode, &(stats->f_cmpgt));
  485. }
  486. else
  487. stats->f_cmpgt.fn_addr = NULL;
  489. typetuple = SearchSysCacheTuple(TYPOID,
  490.  ObjectIdGetDatum(stats->attr->atttypid),
  491. 0, 0, 0);
  492. if (HeapTupleIsValid(typetuple))
  493. stats->outfunc = ((Form_pg_type) GETSTRUCT(typetuple))->typoutput;
  494. else
  495. stats->outfunc = InvalidOid;
  496. }
  497. vacrelstats->va_natts = attr_cnt;
  498. vc_delhilowstats(relid, ((attnums) ? attr_cnt : 0), attnums);
  499. if (attnums)
  500. pfree(attnums);
  501. }
  502. else
  503. {
  504. vacrelstats->va_natts = 0;
  505. vacrelstats->vacattrstats = (VacAttrStats *) NULL;
  506. }
  508. /* we require the relation to be locked until the indices are cleaned */
  509. LockRelation(onerel, AccessExclusiveLock);
  511. GetXmaxRecent(&XmaxRecent);
  513. /* scan it */
  514. vacuum_pages.vpl_num_pages = fraged_pages.vpl_num_pages = 0;
  515. vc_scanheap(vacrelstats, onerel, &vacuum_pages, &fraged_pages);
  517. /* Now open indices */
  518. Irel = (Relation *) NULL;
  519. vc_getindices(vacrelstats->relid, &nindices, &Irel);
  521. if (nindices > 0)
  522. vacrelstats->hasindex = true;
  523. else
  524. vacrelstats->hasindex = false;
  526. /* Clean/scan index relation(s) */
  527. if (Irel != (Relation *) NULL)
  528. {
  529. if (vacuum_pages.vpl_num_pages > 0)
  530. {
  531. for (i = 0; i < nindices; i++)
  532. vc_vaconeind(&vacuum_pages, Irel[i], vacrelstats->num_tuples, 0);
  533. }
  534. else
  535. /* just scan indices to update statistic */
  536. {
  537. for (i = 0; i < nindices; i++)
  538. vc_scanoneind(Irel[i], vacrelstats->num_tuples);
  539. }
  540. }
  542. if (fraged_pages.vpl_num_pages > 0) /* Try to shrink heap */
  543. vc_rpfheap(vacrelstats, onerel, &vacuum_pages, &fraged_pages, nindices, Irel);
  544. else
  545. {
  546. if (Irel != (Relation *) NULL)
  547. vc_clsindices(nindices, Irel);
  548. if (vacuum_pages.vpl_num_pages > 0) /* Clean pages from
  549.  * vacuum_pages list */
  550. vc_vacheap(vacrelstats, onerel, &vacuum_pages);
  551. }
  553. /* ok - free vacuum_pages list of reapped pages */
  554. if (vacuum_pages.vpl_num_pages > 0)
  555. {
  556. vpp = vacuum_pages.vpl_pagedesc;
  557. for (i = 0; i < vacuum_pages.vpl_num_pages; i++, vpp++)
  558. pfree(*vpp);
  559. pfree(vacuum_pages.vpl_pagedesc);
  560. if (fraged_pages.vpl_num_pages > 0)
  561. pfree(fraged_pages.vpl_pagedesc);
  562. }
  564. /* all done with this class */
  565. heap_close(onerel);
  567. /* update statistics in pg_class */
  568. vc_updstats(vacrelstats->relid, vacrelstats->num_pages,
  569. vacrelstats->num_tuples, vacrelstats->hasindex, vacrelstats);
  571. /* next command frees attribute stats */
  572. CommitTransactionCommand();
  573. }
  575. /*
  576.  * vc_scanheap() -- scan an open heap relation
  577.  *
  578.  * This routine sets commit times, constructs vacuum_pages list of
  579.  * empty/uninitialized pages and pages with dead tuples and
  580.  * ~LP_USED line pointers, constructs fraged_pages list of pages
  581.  * appropriate for purposes of shrinking and maintains statistics
  582.  * on the number of live tuples in a heap.
  583.  */
  584. static void
  585. vc_scanheap(VRelStats *vacrelstats, Relation onerel,
  586. VPageList vacuum_pages, VPageList fraged_pages)
  587. {
  588. int nblocks,
  589. blkno;
  590. ItemId itemid;
  591. Buffer buf;
  592. HeapTupleData tuple;
  593. Page page,
  594. tempPage = NULL;
  595. OffsetNumber offnum,
  596. maxoff;
  597. bool pgchanged,
  598. tupgone,
  599. dobufrel,
  600. notup;
  601. char    *relname;
  602. VPageDescr vpc,
  603. vp;
  604. uint32 tups_vacuumed,
  605. num_tuples,
  606. nkeep,
  607. nunused,
  608. ncrash,
  609. empty_pages,
  610. new_pages,
  611. changed_pages,
  612. empty_end_pages;
  613. Size free_size,
  614. usable_free_size;
  615. Size min_tlen = MaxTupleSize;
  616. Size max_tlen = 0;
  617. int32 i;
  618. struct rusage ru0,
  619. ru1;
  620. bool do_shrinking = true;
  621. VTupleLink vtlinks = (VTupleLink) palloc(100 * sizeof(VTupleLinkData));
  622. int num_vtlinks = 0;
  623. int free_vtlinks = 100;
  625. getrusage(RUSAGE_SELF, &ru0);
  627. relname = (RelationGetRelationName(onerel))->data;
  628. elog(MESSAGE_LEVEL, "--Relation %s--", relname);
  630. tups_vacuumed = num_tuples = nkeep = nunused = ncrash = empty_pages =
  631. new_pages = changed_pages = empty_end_pages = 0;
  632. free_size = usable_free_size = 0;
  634. nblocks = RelationGetNumberOfBlocks(onerel);
  636. vpc = (VPageDescr) palloc(sizeof(VPageDescrData) + MaxOffsetNumber * sizeof(OffsetNumber));
  637. vpc->vpd_offsets_used = 0;
  639. for (blkno = 0; blkno < nblocks; blkno++)
  640. {
  641. buf = ReadBuffer(onerel, blkno);
  642. page = BufferGetPage(buf);
  643. vpc->vpd_blkno = blkno;
  644. vpc->vpd_offsets_free = 0;
  646. if (PageIsNew(page))
  647. {
  648. elog(NOTICE, "Rel %s: Uninitialized page %u - fixing",
  649.  relname, blkno);
  650. PageInit(page, BufferGetPageSize(buf), 0);
  651. vpc->vpd_free = ((PageHeader) page)->pd_upper - ((PageHeader) page)->pd_lower;
  652. free_size += (vpc->vpd_free - sizeof(ItemIdData));
  653. new_pages++;
  654. empty_end_pages++;
  655. vc_reappage(vacuum_pages, vpc);
  656. WriteBuffer(buf);
  657. continue;
  658. }
  660. if (PageIsEmpty(page))
  661. {
  662. vpc->vpd_free = ((PageHeader) page)->pd_upper - ((PageHeader) page)->pd_lower;
  663. free_size += (vpc->vpd_free - sizeof(ItemIdData));
  664. empty_pages++;
  665. empty_end_pages++;
  666. vc_reappage(vacuum_pages, vpc);
  667. ReleaseBuffer(buf);
  668. continue;
  669. }
  671. pgchanged = false;
  672. notup = true;
  673. maxoff = PageGetMaxOffsetNumber(page);
  674. for (offnum = FirstOffsetNumber;
  675.  offnum <= maxoff;
  676.  offnum = OffsetNumberNext(offnum))
  677. {
  678. itemid = PageGetItemId(page, offnum);
  680. /*
  681.  * Collect un-used items too - it's possible to have indices
  682.  * pointing here after crash.
  683.  */
  684. if (!ItemIdIsUsed(itemid))
  685. {
  686. vpc->vpd_offsets[vpc->vpd_offsets_free++] = offnum;
  687. nunused++;
  688. continue;
  689. }
  691. tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
  692. tuple.t_len = ItemIdGetLength(itemid);
  693. ItemPointerSet(&(tuple.t_self), blkno, offnum);
  694. tupgone = false;
  696. if (!(tuple.t_data->t_infomask & HEAP_XMIN_COMMITTED))
  697. {
  698. if (tuple.t_data->t_infomask & HEAP_XMIN_INVALID)
  699. tupgone = true;
  700. else if (tuple.t_data->t_infomask & HEAP_MOVED_OFF)
  701. {
  702. if (TransactionIdDidCommit((TransactionId)
  703.    tuple.t_data->t_cmin))
  704. {
  705. tuple.t_data->t_infomask |= HEAP_XMIN_INVALID;
  706. tupgone = true;
  707. }
  708. else
  709. {
  710. tuple.t_data->t_infomask |= HEAP_XMIN_COMMITTED;
  711. pgchanged = true;
  712. }
  713. }
  714. else if (tuple.t_data->t_infomask & HEAP_MOVED_IN)
  715. {
  716. if (!TransactionIdDidCommit((TransactionId)
  717. tuple.t_data->t_cmin))
  718. {
  719. tuple.t_data->t_infomask |= HEAP_XMIN_INVALID;
  720. tupgone = true;
  721. }
  722. else
  723. {
  724. tuple.t_data->t_infomask |= HEAP_XMIN_COMMITTED;
  725. pgchanged = true;
  726. }
  727. }
  728. else
  729. {
  730. if (TransactionIdDidAbort(tuple.t_data->t_xmin))
  731. tupgone = true;
  732. else if (TransactionIdDidCommit(tuple.t_data->t_xmin))
  733. {
  734. tuple.t_data->t_infomask |= HEAP_XMIN_COMMITTED;
  735. pgchanged = true;
  736. }
  737. else if (!TransactionIdIsInProgress(tuple.t_data->t_xmin))
  738. {
  740. /*
  741.  * Not Aborted, Not Committed, Not in Progress -
  742.  * so it's from crashed process. - vadim 11/26/96
  743.  */
  744. ncrash++;
  745. tupgone = true;
  746. }
  747. else
  748. {
  749. elog(NOTICE, "Rel %s: TID %u/%u: InsertTransactionInProgress %u - can't shrink relation",
  750.    relname, blkno, offnum, tuple.t_data->t_xmin);
  751. do_shrinking = false;
  752. }
  753. }
  754. }
  756. /*
  757.  * here we are concerned about tuples with xmin committed and
  758.  * xmax unknown or committed
  759.  */
  760. if (tuple.t_data->t_infomask & HEAP_XMIN_COMMITTED &&
  761. !(tuple.t_data->t_infomask & HEAP_XMAX_INVALID))
  762. {
  763. if (tuple.t_data->t_infomask & HEAP_XMAX_COMMITTED)
  764. {
  765. if (tuple.t_data->t_infomask & HEAP_MARKED_FOR_UPDATE)
  766. {
  767. pgchanged = true;
  768. tuple.t_data->t_infomask |= HEAP_XMAX_INVALID;
  769. }
  770. else
  771. tupgone = true;
  772. }
  773. else if (TransactionIdDidAbort(tuple.t_data->t_xmax))
  774. {
  775. tuple.t_data->t_infomask |= HEAP_XMAX_INVALID;
  776. pgchanged = true;
  777. }
  778. else if (TransactionIdDidCommit(tuple.t_data->t_xmax))
  779. {
  780. if (tuple.t_data->t_infomask & HEAP_MARKED_FOR_UPDATE)
  781. {
  782. tuple.t_data->t_infomask |= HEAP_XMAX_INVALID;
  783. pgchanged = true;
  784. }
  785. else
  786. tupgone = true;
  787. }
  788. else if (!TransactionIdIsInProgress(tuple.t_data->t_xmax))
  789. {
  791. /*
  792.  * Not Aborted, Not Committed, Not in Progress - so it
  793.  * from crashed process. - vadim 06/02/97
  794.  */
  795. tuple.t_data->t_infomask |= HEAP_XMAX_INVALID;
  796. pgchanged = true;
  797. }
  798. else
  799. {
  800. elog(NOTICE, "Rel %s: TID %u/%u: DeleteTransactionInProgress %u - can't shrink relation",
  801.  relname, blkno, offnum, tuple.t_data->t_xmax);
  802. do_shrinking = false;
  803. }
  805. /*
  806.  * If tuple is recently deleted then we must not remove it
  807.  * from relation.
  808.  */
  809. if (tupgone && tuple.t_data->t_xmax >= XmaxRecent)
  810. {
  811. tupgone = false;
  812. nkeep++;
  813. if (!(tuple.t_data->t_infomask & HEAP_XMAX_COMMITTED))
  814. {
  815. tuple.t_data->t_infomask |= HEAP_XMAX_COMMITTED;
  816. pgchanged = true;
  817. }
  819. /*
  820.  * If we do shrinking and this tuple is updated one
  821.  * then remember it to construct updated tuple
  822.  * dependencies.
  823.  */
  824. if (do_shrinking && !(ItemPointerEquals(&(tuple.t_self),
  825.    &(tuple.t_data->t_ctid))))
  826. {
  827. if (free_vtlinks == 0)
  828. {
  829. free_vtlinks = 1000;
  830. vtlinks = (VTupleLink) repalloc(vtlinks,
  831.    (free_vtlinks + num_vtlinks) *
  832.  sizeof(VTupleLinkData));
  833. }
  834. vtlinks[num_vtlinks].new_tid = tuple.t_data->t_ctid;
  835. vtlinks[num_vtlinks].this_tid = tuple.t_self;
  836. free_vtlinks--;
  837. num_vtlinks++;
  838. }
  839. }
  840. }
  842. /*
  843.  * Other checks...
  844.  */
  845. if (!OidIsValid(tuple.t_data->t_oid))
  846. {
  847. elog(NOTICE, "Rel %s: TID %u/%u: OID IS INVALID. TUPGONE %d.",
  848.  relname, blkno, offnum, tupgone);
  849. }
  851. if (tupgone)
  852. {
  853. ItemId lpp;
  855. if (tempPage == (Page) NULL)
  856. {
  857. Size pageSize;
  859. pageSize = PageGetPageSize(page);
  860. tempPage = (Page) palloc(pageSize);
  861. memmove(tempPage, page, pageSize);
  862. }
  864. lpp = &(((PageHeader) tempPage)->pd_linp[offnum - 1]);
  866. /* mark it unused */
  867. lpp->lp_flags &= ~LP_USED;
  869. vpc->vpd_offsets[vpc->vpd_offsets_free++] = offnum;
  870. tups_vacuumed++;
  872. }
  873. else
  874. {
  875. num_tuples++;
  876. notup = false;
  877. if (tuple.t_len < min_tlen)
  878. min_tlen = tuple.t_len;
  879. if (tuple.t_len > max_tlen)
  880. max_tlen = tuple.t_len;
  881. vc_attrstats(onerel, vacrelstats, &tuple);
  882. }
  883. }
  885. if (pgchanged)
  886. {
  887. WriteBuffer(buf);
  888. dobufrel = false;
  889. changed_pages++;
  890. }
  891. else
  892. dobufrel = true;
  893. if (tempPage != (Page) NULL)
  894. { /* Some tuples are gone */
  895. PageRepairFragmentation(tempPage);
  896. vpc->vpd_free = ((PageHeader) tempPage)->pd_upper - ((PageHeader) tempPage)->pd_lower;
  897. free_size += vpc->vpd_free;
  898. vc_reappage(vacuum_pages, vpc);
  899. pfree(tempPage);
  900. tempPage = (Page) NULL;
  901. }
  902. else if (vpc->vpd_offsets_free > 0)
  903. { /* there are only ~LP_USED line pointers */
  904. vpc->vpd_free = ((PageHeader) page)->pd_upper - ((PageHeader) page)->pd_lower;
  905. free_size += vpc->vpd_free;
  906. vc_reappage(vacuum_pages, vpc);
  907. }
  908. if (dobufrel)
  909. ReleaseBuffer(buf);
  910. if (notup)
  911. empty_end_pages++;
  912. else
  913. empty_end_pages = 0;
  914. }
  916. pfree(vpc);
  918. /* save stats in the rel list for use later */
  919. vacrelstats->num_tuples = num_tuples;
  920. vacrelstats->num_pages = nblocks;
  921. /*   vacrelstats->natts = attr_cnt;*/
  922. if (num_tuples == 0)
  923. min_tlen = max_tlen = 0;
  924. vacrelstats->min_tlen = min_tlen;
  925. vacrelstats->max_tlen = max_tlen;
  927. vacuum_pages->vpl_empty_end_pages = empty_end_pages;
  928. fraged_pages->vpl_empty_end_pages = empty_end_pages;
  930. /*
  931.  * Try to make fraged_pages keeping in mind that we can't use free
  932.  * space of "empty" end-pages and last page if it reapped.
  933.  */
  934. if (do_shrinking && vacuum_pages->vpl_num_pages - empty_end_pages > 0)
  935. {
  936. int nusf; /* blocks usefull for re-using */
  938. nusf = vacuum_pages->vpl_num_pages - empty_end_pages;
  939. if ((vacuum_pages->vpl_pagedesc[nusf - 1])->vpd_blkno == nblocks - empty_end_pages - 1)
  940. nusf--;
  942. for (i = 0; i < nusf; i++)
  943. {
  944. vp = vacuum_pages->vpl_pagedesc[i];
  945. if (vc_enough_space(vp, min_tlen))
  946. {
  947. vc_vpinsert(fraged_pages, vp);
  948. usable_free_size += vp->vpd_free;
  949. }
  950. }
  951. }
  953. if (usable_free_size > 0 && num_vtlinks > 0)
  954. {
  955. qsort((char *) vtlinks, num_vtlinks, sizeof(VTupleLinkData),
  956.   vc_cmp_vtlinks);
  957. vacrelstats->vtlinks = vtlinks;
  958. vacrelstats->num_vtlinks = num_vtlinks;
  959. }
  960. else
  961. {
  962. vacrelstats->vtlinks = NULL;
  963. vacrelstats->num_vtlinks = 0;
  964. pfree(vtlinks);
  965. }
  967. getrusage(RUSAGE_SELF, &ru1);
  969. elog(MESSAGE_LEVEL, "Pages %u: Changed %u, Reapped %u, Empty %u, New %u; 
  970. Tup %u: Vac %u, Keep/VTL %u/%u, Crash %u, UnUsed %u, MinLen %u, MaxLen %u; 
  971. Re-using: Free/Avail. Space %u/%u; EndEmpty/Avail. Pages %u/%u. 
  972. Elapsed %u/%u sec.",
  973.  nblocks, changed_pages, vacuum_pages->vpl_num_pages, empty_pages,
  974.  new_pages, num_tuples, tups_vacuumed,
  975.  nkeep, vacrelstats->num_vtlinks, ncrash,
  976.  nunused, min_tlen, max_tlen, free_size, usable_free_size,
  977.  empty_end_pages, fraged_pages->vpl_num_pages,
  978.  ru1.ru_stime.tv_sec - ru0.ru_stime.tv_sec,
  979.  ru1.ru_utime.tv_sec - ru0.ru_utime.tv_sec);
  981. } /* vc_scanheap */
  984. /*
  985.  * vc_rpfheap() -- try to repaire relation' fragmentation
  986.  *
  987.  * This routine marks dead tuples as unused and tries re-use dead space
  988.  * by moving tuples (and inserting indices if needed). It constructs
  989.  * Nvpl list of free-ed pages (moved tuples) and clean indices
  990.  * for them after committing (in hack-manner - without losing locks
  991.  * and freeing memory!) current transaction. It truncates relation
  992.  * if some end-blocks are gone away.
  993.  */
  994. static void
  995. vc_rpfheap(VRelStats *vacrelstats, Relation onerel,
  996.    VPageList vacuum_pages, VPageList fraged_pages, int nindices, Relation *Irel)
  997. {
  998. TransactionId myXID;
  999. CommandId myCID;
  1000. Buffer buf,
  1001. cur_buffer;
  1002. int nblocks,
  1003. blkno;
  1004. Page page,
  1005. ToPage = NULL;
  1006. OffsetNumber offnum = 0,
  1007. maxoff = 0,
  1008. newoff,
  1009. max_offset;
  1010. ItemId itemid,
  1011. newitemid;
  1012. HeapTupleData tuple,
  1013. newtup;
  1014. TupleDesc tupdesc = NULL;
  1015. Datum    *idatum = NULL;
  1016. char    *inulls = NULL;
  1017. InsertIndexResult iresult;
  1018. VPageListData Nvpl;
  1019. VPageDescr cur_page = NULL,
  1020. last_fraged_page,
  1021. last_vacuum_page,
  1022. vpc,
  1023.    *vpp;
  1024. int cur_item = 0;
  1025. IndDesc    *Idesc,
  1026.    *idcur;
  1027. int last_fraged_block,
  1028. last_vacuum_block,
  1029. i = 0;
  1030. Size tuple_len;
  1031. int num_moved,
  1032. num_fraged_pages,
  1033. vacuumed_pages;
  1034. int checked_moved,
  1035. num_tuples,
  1036. keep_tuples = 0;
  1037. bool isempty,
  1038. dowrite,
  1039. chain_tuple_moved;
  1040. struct rusage ru0,
  1041. ru1;
  1043. getrusage(RUSAGE_SELF, &ru0);
  1045. myXID = GetCurrentTransactionId();
  1046. myCID = GetCurrentCommandId();
  1048. if (Irel != (Relation *) NULL) /* preparation for index' inserts */
  1049. {
  1050. vc_mkindesc(onerel, nindices, Irel, &Idesc);
  1051. tupdesc = RelationGetDescr(onerel);
  1052. idatum = (Datum *) palloc(INDEX_MAX_KEYS * sizeof(*idatum));
  1053. inulls = (char *) palloc(INDEX_MAX_KEYS * sizeof(*inulls));
  1054. }
  1056. Nvpl.vpl_num_pages = 0;
  1057. num_fraged_pages = fraged_pages->vpl_num_pages;
  1058. last_fraged_page = fraged_pages->vpl_pagedesc[num_fraged_pages - 1];
  1059. last_fraged_block = last_fraged_page->vpd_blkno;
  1060. Assert(vacuum_pages->vpl_num_pages > vacuum_pages->vpl_empty_end_pages);
  1061. vacuumed_pages = vacuum_pages->vpl_num_pages - vacuum_pages->vpl_empty_end_pages;
  1062. last_vacuum_page = vacuum_pages->vpl_pagedesc[vacuumed_pages - 1];
  1063. last_vacuum_block = last_vacuum_page->vpd_blkno;
  1064. Assert(last_vacuum_block >= last_fraged_block);
  1065. cur_buffer = InvalidBuffer;
  1066. num_moved = 0;
  1068. vpc = (VPageDescr) palloc(sizeof(VPageDescrData) + MaxOffsetNumber * sizeof(OffsetNumber));
  1069. vpc->vpd_offsets_used = vpc->vpd_offsets_free = 0;
  1071. nblocks = vacrelstats->num_pages;
  1072. for (blkno = nblocks - vacuum_pages->vpl_empty_end_pages - 1;; blkno--)
  1073. {
  1074. /* if it's reapped page and it was used by me - quit */
  1075. if (blkno == last_fraged_block && last_fraged_page->vpd_offsets_used > 0)
  1076. break;
  1078. buf = ReadBuffer(onerel, blkno);
  1079. page = BufferGetPage(buf);
  1081. vpc->vpd_offsets_free = 0;
  1083. isempty = PageIsEmpty(page);
  1085. dowrite = false;
  1086. if (blkno == last_vacuum_block) /* it's reapped page */
  1087. {
  1088. if (last_vacuum_page->vpd_offsets_free > 0) /* there are dead tuples */
  1089. { /* on this page - clean */
  1090. Assert(!isempty);
  1091. vc_vacpage(page, last_vacuum_page);
  1092. dowrite = true;
  1093. }
  1094. else
  1095. Assert(isempty);
  1096. --vacuumed_pages;
  1097. Assert(vacuumed_pages > 0);
  1098. /* get prev reapped page from vacuum_pages */
  1099. last_vacuum_page = vacuum_pages->vpl_pagedesc[vacuumed_pages - 1];
  1100. last_vacuum_block = last_vacuum_page->vpd_blkno;
  1101. if (blkno == last_fraged_block) /* this page in
  1102.  * fraged_pages too */
  1103. {
  1104. --num_fraged_pages;
  1105. Assert(num_fraged_pages > 0);
  1106. Assert(last_fraged_page->vpd_offsets_used == 0);
  1107. /* get prev reapped page from fraged_pages */
  1108. last_fraged_page = fraged_pages->vpl_pagedesc[num_fraged_pages - 1];
  1109. last_fraged_block = last_fraged_page->vpd_blkno;
  1110. }
  1111. Assert(last_fraged_block <= last_vacuum_block);
  1112. if (isempty)
  1113. {
  1114. ReleaseBuffer(buf);
  1115. continue;
  1116. }
  1117. }
  1118. else
  1119. Assert(!isempty);
  1121. chain_tuple_moved = false; /* no one chain-tuple was moved
  1122.  * off this page, yet */
  1123. vpc->vpd_blkno = blkno;
  1124. maxoff = PageGetMaxOffsetNumber(page);
  1125. for (offnum = FirstOffsetNumber;
  1126.  offnum <= maxoff;
  1127.  offnum = OffsetNumberNext(offnum))
  1128. {
  1129. itemid = PageGetItemId(page, offnum);
  1131. if (!ItemIdIsUsed(itemid))
  1132. continue;
  1134. tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
  1135. tuple_len = tuple.t_len = ItemIdGetLength(itemid);
  1136. ItemPointerSet(&(tuple.t_self), blkno, offnum);
  1138. if (!(tuple.t_data->t_infomask & HEAP_XMIN_COMMITTED))
  1139. {
  1140. if ((TransactionId) tuple.t_data->t_cmin != myXID)
  1141. elog(ERROR, "Invalid XID in t_cmin");
  1142. if (tuple.t_data->t_infomask & HEAP_MOVED_IN)
  1143. elog(ERROR, "HEAP_MOVED_IN was not expected");
  1145. /*
  1146.  * If this (chain) tuple is moved by me already then I
  1147.  * have to check is it in vpc or not - i.e. is it moved
  1148.  * while cleaning this page or some previous one.
  1149.  */
  1150. if (tuple.t_data->t_infomask & HEAP_MOVED_OFF)
  1151. {
  1152. if (keep_tuples == 0)
  1153. continue;
  1154. if (chain_tuple_moved) /* some chains was moved
  1155.  * while */
  1156. { /* cleaning this page */
  1157. Assert(vpc->vpd_offsets_free > 0);
  1158. for (i = 0; i < vpc->vpd_offsets_free; i++)
  1159. {
  1160. if (vpc->vpd_offsets[i] == offnum)
  1161. break;
  1162. }
  1163. if (i >= vpc->vpd_offsets_free) /* not found */
  1164. {
  1165. vpc->vpd_offsets[vpc->vpd_offsets_free++] = offnum;
  1166. keep_tuples--;
  1167. }
  1168. }
  1169. else
  1170. {
  1171. vpc->vpd_offsets[vpc->vpd_offsets_free++] = offnum;
  1172. keep_tuples--;
  1173. }
  1174. continue;
  1175. }
  1176. elog(ERROR, "HEAP_MOVED_OFF was expected");
  1177. }
  1179. /*
  1180.  * If this tuple is in the chain of tuples created in updates
  1181.  * by "recent" transactions then we have to move all chain of
  1182.  * tuples to another places.
  1183.  */
  1184. if ((tuple.t_data->t_infomask & HEAP_UPDATED &&
  1185.  tuple.t_data->t_xmin >= XmaxRecent) ||
  1186. (!(tuple.t_data->t_infomask & HEAP_XMAX_INVALID) &&
  1187.  !(ItemPointerEquals(&(tuple.t_self), &(tuple.t_data->t_ctid)))))
  1188. {
  1189. Buffer Cbuf = buf;
  1190. Page Cpage;
  1191. ItemId Citemid;
  1192. ItemPointerData Ctid;
  1193. HeapTupleData tp = tuple;
  1194. Size tlen = tuple_len;
  1195. VTupleMove vtmove = (VTupleMove)
  1196. palloc(100 * sizeof(VTupleMoveData));
  1197. int num_vtmove = 0;
  1198. int free_vtmove = 100;
  1199. VPageDescr to_vpd = fraged_pages->vpl_pagedesc[0];
  1200. int to_item = 0;
  1201. bool freeCbuf = false;
  1202. int ti;
  1204. if (vacrelstats->vtlinks == NULL)
  1205. elog(ERROR, "No one parent tuple was found");
  1206. if (cur_buffer != InvalidBuffer)
  1207. {
  1208. WriteBuffer(cur_buffer);
  1209. cur_buffer = InvalidBuffer;
  1210. }
  1212. /*
  1213.  * If this tuple is in the begin/middle of the chain then
  1214.  * we have to move to the end of chain.
  1215.  */
  1216. while (!(tp.t_data->t_infomask & HEAP_XMAX_INVALID) &&
  1217. !(ItemPointerEquals(&(tp.t_self), &(tp.t_data->t_ctid))))
  1218. {
  1219. Ctid = tp.t_data->t_ctid;
  1220. if (freeCbuf)
  1221. ReleaseBuffer(Cbuf);
  1222. freeCbuf = true;
  1223. Cbuf = ReadBuffer(onerel,
  1224.   ItemPointerGetBlockNumber(&Ctid));
  1225. Cpage = BufferGetPage(Cbuf);
  1226. Citemid = PageGetItemId(Cpage,
  1227.   ItemPointerGetOffsetNumber(&Ctid));
  1228. if (!ItemIdIsUsed(Citemid))
  1229. {
  1230. /*
  1231.  * This means that in the middle of chain there was
  1232.  * tuple updated by older (than XmaxRecent) xaction
  1233.  * and this tuple is already deleted by me. Actually,
  1234.  * upper part of chain should be removed and seems 
  1235.  * that this should be handled in vc_scanheap(), but
  1236.  * it's not implemented at the moment and so we
  1237.  * just stop shrinking here.
  1238.  */
  1239. ReleaseBuffer(Cbuf);
  1240. pfree(vtmove);
  1241. vtmove = NULL;
  1242. elog(NOTICE, "Child itemid in update-chain marked as unused - can't continue vc_rpfheap");
  1243. break;
  1244. }
  1245. tp.t_data = (HeapTupleHeader) PageGetItem(Cpage, Citemid);
  1246. tp.t_self = Ctid;
  1247. tlen = tp.t_len = ItemIdGetLength(Citemid);
  1248. }
  1249. if (vtmove == NULL)
  1250. break;
  1251. /* first, can chain be moved ? */
  1252. for (;;)
  1253. {
  1254. if (!vc_enough_space(to_vpd, tlen))
  1255. {
  1256. if (to_vpd != last_fraged_page &&
  1257.  !vc_enough_space(to_vpd, vacrelstats->min_tlen))
  1258. {
  1259. Assert(num_fraged_pages > to_item + 1);
  1260. memmove(fraged_pages->vpl_pagedesc + to_item,
  1261. fraged_pages->vpl_pagedesc + to_item + 1,
  1262. sizeof(VPageDescr *) * (num_fraged_pages - to_item - 1));
  1263. num_fraged_pages--;
  1264. Assert(last_fraged_page == fraged_pages->vpl_pagedesc[num_fraged_pages - 1]);
  1265. }
  1266. for (i = 0; i < num_fraged_pages; i++)
  1267. {
  1268. if (vc_enough_space(fraged_pages->vpl_pagedesc[i], tlen))
  1269. break;
  1270. }
  1271. if (i == num_fraged_pages) /* can't move item
  1272.  * anywhere */
  1273. {
  1274. for (i = 0; i < num_vtmove; i++)
  1275. {
  1276. Assert(vtmove[i].vpd->vpd_offsets_used > 0);
  1277. (vtmove[i].vpd->vpd_offsets_used)--;
  1278. }
  1279. num_vtmove = 0;
  1280. break;
  1281. }
  1282. to_item = i;
  1283. to_vpd = fraged_pages->vpl_pagedesc[to_item];
  1284. }
  1285. to_vpd->vpd_free -= MAXALIGN(tlen);
  1286. if (to_vpd->vpd_offsets_used >= to_vpd->vpd_offsets_free)
  1287. to_vpd->vpd_free -= MAXALIGN(sizeof(ItemIdData));
  1288. (to_vpd->vpd_offsets_used)++;
  1289. if (free_vtmove == 0)
  1290. {
  1291. free_vtmove = 1000;
  1292. vtmove = (VTupleMove) repalloc(vtmove,
  1293.  (free_vtmove + num_vtmove) *
  1294.  sizeof(VTupleMoveData));
  1295. }
  1296. vtmove[num_vtmove].tid = tp.t_self;
  1297. vtmove[num_vtmove].vpd = to_vpd;
  1298. if (to_vpd->vpd_offsets_used == 1)
  1299. vtmove[num_vtmove].cleanVpd = true;
  1300. else
  1301. vtmove[num_vtmove].cleanVpd = false;
  1302. free_vtmove--;
  1303. num_vtmove++;
  1305. /*
  1306.  * All done ?
  1307.  */
  1308. if (!(tp.t_data->t_infomask & HEAP_UPDATED) ||
  1309. tp.t_data->t_xmin < XmaxRecent)
  1310. break;
  1312. /*
  1313.  * Well, try to find tuple with old row version
  1314.  */
  1315. for (;;)
  1316. {
  1317. Buffer Pbuf;
  1318. Page Ppage;
  1319. ItemId Pitemid;
  1320. HeapTupleData Ptp;
  1321. VTupleLinkData vtld,
  1322.    *vtlp;
  1324. vtld.new_tid = tp.t_self;
  1325. vtlp = (VTupleLink)
  1326. vc_find_eq((void *) (vacrelstats->vtlinks),
  1327.    vacrelstats->num_vtlinks,
  1328.    sizeof(VTupleLinkData),
  1329.    (void *) &vtld,
  1330.    vc_cmp_vtlinks);
  1331. if (vtlp == NULL)
  1332. elog(ERROR, "Parent tuple was not found");
  1333. tp.t_self = vtlp->this_tid;
  1334. Pbuf = ReadBuffer(onerel,
  1335. ItemPointerGetBlockNumber(&(tp.t_self)));
  1336. Ppage = BufferGetPage(Pbuf);
  1337. Pitemid = PageGetItemId(Ppage,
  1338.    ItemPointerGetOffsetNumber(&(tp.t_self)));
  1339. if (!ItemIdIsUsed(Pitemid))
  1340. elog(ERROR, "Parent itemid marked as unused");
  1341. Ptp.t_data = (HeapTupleHeader) PageGetItem(Ppage, Pitemid);
  1342. Assert(ItemPointerEquals(&(vtld.new_tid),
  1343. &(Ptp.t_data->t_ctid)));
  1344. /*
  1345.  * Read above about cases when !ItemIdIsUsed(Citemid)
  1346.  * (child item is removed)... Due to the fact that
  1347.  * at the moment we don't remove unuseful part of 
  1348.  * update-chain, it's possible to get too old
  1349.  * parent row here. Like as in the case which 
  1350.  * caused this problem, we stop shrinking here.
  1351.  * I could try to find real parent row but want
  1352.  * not to do it because of real solution will
  1353.  * be implemented anyway, latter, and we are too
  1354.  * close to 6.5 release. - vadim 06/11/99
  1355.  */
  1356. if (Ptp.t_data->t_xmax != tp.t_data->t_xmin)
  1357. {
  1358. if (freeCbuf)
  1359. ReleaseBuffer(Cbuf);
  1360. freeCbuf = false;
  1361. ReleaseBuffer(Pbuf);
  1362. for (i = 0; i < num_vtmove; i++)
  1363. {
  1364. Assert(vtmove[i].vpd->vpd_offsets_used > 0);
  1365. (vtmove[i].vpd->vpd_offsets_used)--;
  1366. }
  1367. num_vtmove = 0;
  1368. elog(NOTICE, "Too old parent tuple found - can't continue vc_rpfheap");
  1369. break;
  1370. }
  1371. #ifdef NOT_USED /* I'm not sure that this will wotk properly... */
  1372. /*
  1373.  * If this tuple is updated version of row and it
  1374.  * was created by the same transaction then no one
  1375.  * is interested in this tuple - mark it as
  1376.  * removed.
  1377.  */
  1378. if (Ptp.t_data->t_infomask & HEAP_UPDATED &&
  1379. Ptp.t_data->t_xmin == Ptp.t_data->t_xmax)
  1380. {
  1381. TransactionIdStore(myXID,
  1382. (TransactionId *) &(Ptp.t_data->t_cmin));
  1383. Ptp.t_data->t_infomask &=
  1384. ~(HEAP_XMIN_COMMITTED | HEAP_XMIN_INVALID | HEAP_MOVED_IN);
  1385. Ptp.t_data->t_infomask |= HEAP_MOVED_OFF;
  1386. WriteBuffer(Pbuf);
  1387. continue;
  1388. }
  1389. #endif
  1390. tp.t_data = Ptp.t_data;
  1391. tlen = tp.t_len = ItemIdGetLength(Pitemid);
  1392. if (freeCbuf)
  1393. ReleaseBuffer(Cbuf);
  1394. Cbuf = Pbuf;
  1395. freeCbuf = true;
  1396. break;
  1397. }
  1398. if (num_vtmove == 0)
  1399. break;
  1400. }
  1401. if (freeCbuf)
  1402. ReleaseBuffer(Cbuf);
  1403. if (num_vtmove == 0) /* chain can't be moved */
  1404. {
  1405. pfree(vtmove);
  1406. break;
  1407. }
  1408. ItemPointerSetInvalid(&Ctid);
  1409. for (ti = 0; ti < num_vtmove; ti++)
  1410. {
  1411. /* Get tuple from chain */
  1412. tuple.t_self = vtmove[ti].tid;
  1413. Cbuf = ReadBuffer(onerel,
  1414.  ItemPointerGetBlockNumber(&(tuple.t_self)));
  1415. Cpage = BufferGetPage(Cbuf);
  1416. Citemid = PageGetItemId(Cpage,
  1417. ItemPointerGetOffsetNumber(&(tuple.t_self)));
  1418. tuple.t_data = (HeapTupleHeader) PageGetItem(Cpage, Citemid);
  1419. tuple_len = tuple.t_len = ItemIdGetLength(Citemid);
  1420. /* Get page to move in */
  1421. cur_buffer = ReadBuffer(onerel, vtmove[ti].vpd->vpd_blkno);
  1423. /*
  1424.  * We should LockBuffer(cur_buffer) but don't, at the
  1425.  * moment. If you'll do LockBuffer then UNLOCK it
  1426.  * before index_insert: unique btree-s call heap_fetch
  1427.  * to get t_infomask of inserted heap tuple !!!
  1428.  */
  1429. ToPage = BufferGetPage(cur_buffer);
  1430. /* if this page was not used before - clean it */
  1431. if (!PageIsEmpty(ToPage) && vtmove[ti].cleanVpd)
  1432. vc_vacpage(ToPage, vtmove[ti].vpd);
  1433. heap_copytuple_with_tuple(&tuple, &newtup);
  1434. RelationInvalidateHeapTuple(onerel, &tuple);
  1435. TransactionIdStore(myXID, (TransactionId *) &(newtup.t_data->t_cmin));
  1436. newtup.t_data->t_infomask &=
  1437. ~(HEAP_XMIN_COMMITTED | HEAP_XMIN_INVALID | HEAP_MOVED_OFF);
  1438. newtup.t_data->t_infomask |= HEAP_MOVED_IN;
  1439. newoff = PageAddItem(ToPage, (Item) newtup.t_data, tuple_len,
  1440.  InvalidOffsetNumber, LP_USED);
  1441. if (newoff == InvalidOffsetNumber)
  1442. {
  1443. elog(ERROR, "
  1444. moving chain: failed to add item with len = %u to page %u",
  1445.  tuple_len, vtmove[ti].vpd->vpd_blkno);
  1446. }
  1447. newitemid = PageGetItemId(ToPage, newoff);
  1448. pfree(newtup.t_data);
  1449. newtup.t_data = (HeapTupleHeader) PageGetItem(ToPage, newitemid);
  1450. ItemPointerSet(&(newtup.t_self), vtmove[ti].vpd->vpd_blkno, newoff);
  1452. /*
  1453.  * Set t_ctid pointing to itself for last tuple in
  1454.  * chain and to next tuple in chain otherwise.
  1455.  */
  1456. if (!ItemPointerIsValid(&Ctid))
  1457. newtup.t_data->t_ctid = newtup.t_self;
  1458. else
  1459. newtup.t_data->t_ctid = Ctid;
  1460. Ctid = newtup.t_self;
  1462. TransactionIdStore(myXID, (TransactionId *) &(tuple.t_data->t_cmin));
  1463. tuple.t_data->t_infomask &=
  1464. ~(HEAP_XMIN_COMMITTED | HEAP_XMIN_INVALID | HEAP_MOVED_IN);
  1465. tuple.t_data->t_infomask |= HEAP_MOVED_OFF;
  1467. num_moved++;
  1469. /*
  1470.  * Remember that we moved tuple from the current page
  1471.  * (corresponding index tuple will be cleaned).
  1472.  */
  1473. if (Cbuf == buf)
  1474. vpc->vpd_offsets[vpc->vpd_offsets_free++] =
  1475. ItemPointerGetOffsetNumber(&(tuple.t_self));
  1476. else
  1477. keep_tuples++;
  1479. if (Irel != (Relation *) NULL)
  1480. {
  1481. for (i = 0, idcur = Idesc; i < nindices; i++, idcur++)
  1482. {
  1483. FormIndexDatum(idcur->natts,
  1484.    (AttrNumber *) &(idcur->tform->indkey[0]),
  1485.    &newtup,
  1486.    tupdesc,
  1487.    idatum,
  1488.    inulls,
  1489.    idcur->finfoP);
  1490. iresult = index_insert(Irel[i],
  1491.    idatum,
  1492.    inulls,
  1493.    &newtup.t_self,
  1494.    onerel);
  1495. if (iresult)
  1496. pfree(iresult);
  1497. }
  1498. }
  1499. WriteBuffer(cur_buffer);
  1500. if (Cbuf == buf)
  1501. ReleaseBuffer(Cbuf);
  1502. else
  1503. WriteBuffer(Cbuf);
  1504. }
  1505. cur_buffer = InvalidBuffer;
  1506. pfree(vtmove);
  1507. chain_tuple_moved = true;
  1508. continue;
  1509. }
  1511. /* try to find new page for this tuple */
  1512. if (cur_buffer == InvalidBuffer ||
  1513. !vc_enough_space(cur_page, tuple_len))
  1514. {
  1515. if (cur_buffer != InvalidBuffer)
  1516. {
  1517. WriteBuffer(cur_buffer);
  1518. cur_buffer = InvalidBuffer;
  1520. /*
  1521.  * If no one tuple can't be added to this page -
  1522.  * remove page from fraged_pages. - vadim 11/27/96
  1523.  *
  1524.  * But we can't remove last page - this is our
  1525.  * "show-stopper" !!! - vadim 02/25/98
  1526.  */
  1527. if (cur_page != last_fraged_page &&
  1528. !vc_enough_space(cur_page, vacrelstats->min_tlen))
  1529. {
  1530. Assert(num_fraged_pages > cur_item + 1);
  1531. memmove(fraged_pages->vpl_pagedesc + cur_item,
  1532. fraged_pages->vpl_pagedesc + cur_item + 1,
  1533. sizeof(VPageDescr *) * (num_fraged_pages - cur_item - 1));
  1534. num_fraged_pages--;
  1535. Assert(last_fraged_page == fraged_pages->vpl_pagedesc[num_fraged_pages - 1]);
  1536. }
  1537. }
  1538. for (i = 0; i < num_fraged_pages; i++)
  1539. {
  1540. if (vc_enough_space(fraged_pages->vpl_pagedesc[i], tuple_len))
  1541. break;
  1542. }
  1543. if (i == num_fraged_pages)
  1544. break; /* can't move item anywhere */
  1545. cur_item = i;
  1546. cur_page = fraged_pages->vpl_pagedesc[cur_item];
  1547. cur_buffer = ReadBuffer(onerel, cur_page->vpd_blkno);
  1548. ToPage = BufferGetPage(cur_buffer);
  1549. /* if this page was not used before - clean it */
  1550. if (!PageIsEmpty(ToPage) && cur_page->vpd_offsets_used == 0)
  1551. vc_vacpage(ToPage, cur_page);
  1552. }
  1554. /* copy tuple */
  1555. heap_copytuple_with_tuple(&tuple, &newtup);
  1557. RelationInvalidateHeapTuple(onerel, &tuple);
  1559. /*
  1560.  * Mark new tuple as moved_in by vacuum and store vacuum XID
  1561.  * in t_cmin !!!
  1562.  */
  1563. TransactionIdStore(myXID, (TransactionId *) &(newtup.t_data->t_cmin));
  1564. newtup.t_data->t_infomask &=
  1565. ~(HEAP_XMIN_COMMITTED | HEAP_XMIN_INVALID | HEAP_MOVED_OFF);
  1566. newtup.t_data->t_infomask |= HEAP_MOVED_IN;
  1568. /* add tuple to the page */
  1569. newoff = PageAddItem(ToPage, (Item) newtup.t_data, tuple_len,
  1570.  InvalidOffsetNumber, LP_USED);
  1571. if (newoff == InvalidOffsetNumber)
  1572. {
  1573. elog(ERROR, "
  1574. failed to add item with len = %u to page %u (free space %u, nusd %u, noff %u)",
  1575.  tuple_len, cur_page->vpd_blkno, cur_page->vpd_free,
  1576.  cur_page->vpd_offsets_used, cur_page->vpd_offsets_free);
  1577. }
  1578. newitemid = PageGetItemId(ToPage, newoff);
  1579. pfree(newtup.t_data);
  1580. newtup.t_data = (HeapTupleHeader) PageGetItem(ToPage, newitemid);
  1581. ItemPointerSet(&(newtup.t_data->t_ctid), cur_page->vpd_blkno, newoff);
  1582. newtup.t_self = newtup.t_data->t_ctid;
  1584. /*
  1585.  * Mark old tuple as moved_off by vacuum and store vacuum XID
  1586.  * in t_cmin !!!
  1587.  */
  1588. TransactionIdStore(myXID, (TransactionId *) &(tuple.t_data->t_cmin));
  1589. tuple.t_data->t_infomask &=
  1590. ~(HEAP_XMIN_COMMITTED | HEAP_XMIN_INVALID | HEAP_MOVED_IN);
  1591. tuple.t_data->t_infomask |= HEAP_MOVED_OFF;
  1593. cur_page->vpd_offsets_used++;
  1594. num_moved++;
  1595. cur_page->vpd_free = ((PageHeader) ToPage)->pd_upper - ((PageHeader) ToPage)->pd_lower;
  1596. vpc->vpd_offsets[vpc->vpd_offsets_free++] = offnum;
  1598. /* insert index' tuples if needed */
  1599. if (Irel != (Relation *) NULL)
  1600. {
  1601. for (i = 0, idcur = Idesc; i < nindices; i++, idcur++)
  1602. {
  1603. FormIndexDatum(idcur->natts,
  1604.    (AttrNumber *) &(idcur->tform->indkey[0]),
  1605.    &newtup,
  1606.    tupdesc,
  1607.    idatum,
  1608.    inulls,
  1609.    idcur->finfoP);
  1610. iresult = index_insert(Irel[i],
  1611.    idatum,
  1612.    inulls,
  1613.    &newtup.t_self,
  1614.    onerel);
  1615. if (iresult)
  1616. pfree(iresult);
  1617. }
  1618. }
  1620. } /* walk along page */
  1622. if (offnum < maxoff && keep_tuples > 0)
  1623. {
  1624. OffsetNumber off;
  1626. for (off = OffsetNumberNext(offnum);
  1627.  off <= maxoff;
  1628.  off = OffsetNumberNext(off))
  1629. {
  1630. itemid = PageGetItemId(page, off);
  1631. if (!ItemIdIsUsed(itemid))
  1632. continue;
  1633. tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
  1634. if (tuple.t_data->t_infomask & HEAP_XMIN_COMMITTED)
  1635. continue;
  1636. if ((TransactionId) tuple.t_data->t_cmin != myXID)
  1637. elog(ERROR, "Invalid XID in t_cmin (4)");
  1638. if (tuple.t_data->t_infomask & HEAP_MOVED_IN)
  1639. elog(ERROR, "HEAP_MOVED_IN was not expected (2)");
  1640. if (tuple.t_data->t_infomask & HEAP_MOVED_OFF)
  1641. {
  1642. if (chain_tuple_moved) /* some chains was moved
  1643.  * while */
  1644. { /* cleaning this page */
  1645. Assert(vpc->vpd_offsets_free > 0);
  1646. for (i = 0; i < vpc->vpd_offsets_free; i++)
  1647. {
  1648. if (vpc->vpd_offsets[i] == off)
  1649. break;
  1650. }
  1651. if (i >= vpc->vpd_offsets_free) /* not found */
  1652. {
  1653. vpc->vpd_offsets[vpc->vpd_offsets_free++] = off;
  1654. Assert(keep_tuples > 0);
  1655. keep_tuples--;
  1656. }
  1657. }
  1658. else
  1659. {
  1660. vpc->vpd_offsets[vpc->vpd_offsets_free++] = off;
  1661. Assert(keep_tuples > 0);
  1662. keep_tuples--;
  1663. }
  1664. }
  1665. }
  1666. }
  1668. if (vpc->vpd_offsets_free > 0) /* some tuples were moved */
  1669. {
  1670. if (chain_tuple_moved) /* else - they are ordered */
  1671. {
  1672. qsort((char *) (vpc->vpd_offsets), vpc->vpd_offsets_free,
  1673.   sizeof(OffsetNumber), vc_cmp_offno);
  1674. }
  1675. vc_reappage(&Nvpl, vpc);
  1676. WriteBuffer(buf);
  1677. }
  1678. else if (dowrite)
  1679. WriteBuffer(buf);
  1680. else
  1681. ReleaseBuffer(buf);
  1683. if (offnum <= maxoff)
  1684. break; /* some item(s) left */
  1686. } /* walk along relation */
  1688. blkno++; /* new number of blocks */
  1690. if (cur_buffer != InvalidBuffer)
  1691. {
  1692. Assert(num_moved > 0);
  1693. WriteBuffer(cur_buffer);
  1694. }
  1696. if (num_moved > 0)
  1697. {
  1699. /*
  1700.  * We have to commit our tuple' movings before we'll truncate
  1701.  * relation, but we shouldn't lose our locks. And so - quick hack:
  1702.  * flush buffers and record status of current transaction as
  1703.  * committed, and continue. - vadim 11/13/96
  1704.  */
  1705. FlushBufferPool(!TransactionFlushEnabled());
  1706. TransactionIdCommit(myXID);
  1707. FlushBufferPool(!TransactionFlushEnabled());
  1708. }
  1710. /*
  1711.  * Clean uncleaned reapped pages from vacuum_pages list list and set
  1712.  * xmin committed for inserted tuples
  1713.  */
  1714. checked_moved = 0;
  1715. for (i = 0, vpp = vacuum_pages->vpl_pagedesc; i < vacuumed_pages; i++, vpp++)
  1716. {
  1717. Assert((*vpp)->vpd_blkno < blkno);
  1718. buf = ReadBuffer(onerel, (*vpp)->vpd_blkno);
  1719. page = BufferGetPage(buf);
  1720. if ((*vpp)->vpd_offsets_used == 0) /* this page was not used */
  1721. {
  1722. if (!PageIsEmpty(page))
  1723. vc_vacpage(page, *vpp);
  1724. }
  1725. else
  1726. /* this page was used */
  1727. {
  1728. num_tuples = 0;
  1729. max_offset = PageGetMaxOffsetNumber(page);
  1730. for (newoff = FirstOffsetNumber;
  1731.  newoff <= max_offset;
  1732.  newoff = OffsetNumberNext(newoff))
  1733. {
  1734. itemid = PageGetItemId(page, newoff);
  1735. if (!ItemIdIsUsed(itemid))
  1736. continue;
  1737. tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
  1738. if (!(tuple.t_data->t_infomask & HEAP_XMIN_COMMITTED))
  1739. {
  1740. if ((TransactionId) tuple.t_data->t_cmin != myXID)
  1741. elog(ERROR, "Invalid XID in t_cmin (2)");
  1742. if (tuple.t_data->t_infomask & HEAP_MOVED_IN)
  1743. {
  1744. tuple.t_data->t_infomask |= HEAP_XMIN_COMMITTED;
  1745. num_tuples++;
  1746. }
  1747. else if (tuple.t_data->t_infomask & HEAP_MOVED_OFF)
  1748. tuple.t_data->t_infomask |= HEAP_XMIN_INVALID;
  1749. else
  1750. elog(ERROR, "HEAP_MOVED_OFF/HEAP_MOVED_IN was expected");
  1751. }
  1752. }
  1753. Assert((*vpp)->vpd_offsets_used == num_tuples);
  1754. checked_moved += num_tuples;
  1755. }
  1756. WriteBuffer(buf);
  1757. }
  1758. Assert(num_moved == checked_moved);
  1760. getrusage(RUSAGE_SELF, &ru1);
  1762. elog(MESSAGE_LEVEL, "Rel %s: Pages: %u --> %u; Tuple(s) moved: %u. 
  1763. Elapsed %u/%u sec.",
  1764.  (RelationGetRelationName(onerel))->data,
  1765.  nblocks, blkno, num_moved,
  1766.  ru1.ru_stime.tv_sec - ru0.ru_stime.tv_sec,
  1767.  ru1.ru_utime.tv_sec - ru0.ru_utime.tv_sec);
  1769. if (Nvpl.vpl_num_pages > 0)
  1770. {
  1771. /* vacuum indices again if needed */
  1772. if (Irel != (Relation *) NULL)
  1773. {
  1774. VPageDescr *vpleft,
  1775.    *vpright,
  1776. vpsave;
  1778. /* re-sort Nvpl.vpl_pagedesc */
  1779. for (vpleft = Nvpl.vpl_pagedesc,
  1780.  vpright = Nvpl.vpl_pagedesc + Nvpl.vpl_num_pages - 1;
  1781.  vpleft < vpright; vpleft++, vpright--)
  1782. {
  1783. vpsave = *vpleft;
  1784. *vpleft = *vpright;
  1785. *vpright = vpsave;
  1786. }
  1787. Assert(keep_tuples >= 0);
  1788. for (i = 0; i < nindices; i++)
  1789. vc_vaconeind(&Nvpl, Irel[i],
  1790.  vacrelstats->num_tuples, keep_tuples);
  1791. }
  1793. /*
  1794.  * clean moved tuples from last page in Nvpl list
  1795.  */
  1796. if (vpc->vpd_blkno == blkno - 1 && vpc->vpd_offsets_free > 0)
  1797. {
  1798. buf = ReadBuffer(onerel, vpc->vpd_blkno);
  1799. page = BufferGetPage(buf);
  1800. num_tuples = 0;
  1801. for (offnum = FirstOffsetNumber;
  1802.  offnum <= maxoff;
  1803.  offnum = OffsetNumberNext(offnum))
  1804. {
  1805. itemid = PageGetItemId(page, offnum);
  1806. if (!ItemIdIsUsed(itemid))
  1807. continue;
  1808. tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
  1810. if (!(tuple.t_data->t_infomask & HEAP_XMIN_COMMITTED))
  1811. {
  1812. if ((TransactionId) tuple.t_data->t_cmin != myXID)
  1813. elog(ERROR, "Invalid XID in t_cmin (3)");
  1814. if (tuple.t_data->t_infomask & HEAP_MOVED_OFF)
  1815. {
  1816. itemid->lp_flags &= ~LP_USED;
  1817. num_tuples++;
  1818. }
  1819. else
  1820. elog(ERROR, "HEAP_MOVED_OFF was expected (2)");
  1821. }
  1823. }
  1824. Assert(vpc->vpd_offsets_free == num_tuples);
  1825. PageRepairFragmentation(page);
  1826. WriteBuffer(buf);
  1827. }
  1829. /* now - free new list of reapped pages */
  1830. vpp = Nvpl.vpl_pagedesc;
  1831. for (i = 0; i < Nvpl.vpl_num_pages; i++, vpp++)
  1832. pfree(*vpp);
  1833. pfree(Nvpl.vpl_pagedesc);
  1834. }
  1836. /* truncate relation */
  1837. if (blkno < nblocks)
  1838. {
  1839. i = BlowawayRelationBuffers(onerel, blkno);
  1840. if (i < 0)
  1841. elog(FATAL, "VACUUM (vc_rpfheap): BlowawayRelationBuffers returned %d", i);
  1842. blkno = smgrtruncate(DEFAULT_SMGR, onerel, blkno);
  1843. Assert(blkno >= 0);
  1844. vacrelstats->num_pages = blkno; /* set new number of blocks */
  1845. }
  1847. if (Irel != (Relation *) NULL) /* pfree index' allocations */
  1848. {
  1849. pfree(Idesc);
  1850. pfree(idatum);
  1851. pfree(inulls);
  1852. vc_clsindices(nindices, Irel);
  1853. }
  1855. pfree(vpc);
  1856. if (vacrelstats->vtlinks != NULL)
  1857. pfree(vacrelstats->vtlinks);
  1859. } /* vc_rpfheap */
  1861. /*
  1862.  * vc_vacheap() -- free dead tuples
  1863.  *
  1864.  * This routine marks dead tuples as unused and truncates relation
  1865.  * if there are "empty" end-blocks.
  1866.  */
  1867. static void
  1868. vc_vacheap(VRelStats *vacrelstats, Relation onerel, VPageList vacuum_pages)
  1869. {
  1870. Buffer buf;
  1871. Page page;
  1872. VPageDescr *vpp;
  1873. int nblocks;
  1874. int i;
  1876. nblocks = vacuum_pages->vpl_num_pages;
  1877. nblocks -= vacuum_pages->vpl_empty_end_pages; /* nothing to do with
  1878.  * them */
  1880. for (i = 0, vpp = vacuum_pages->vpl_pagedesc; i < nblocks; i++, vpp++)
  1881. {
  1882. if ((*vpp)->vpd_offsets_free > 0)
  1883. {
  1884. buf = ReadBuffer(onerel, (*vpp)->vpd_blkno);
  1885. page = BufferGetPage(buf);
  1886. vc_vacpage(page, *vpp);
  1887. WriteBuffer(buf);
  1888. }
  1889. }
  1891. /* truncate relation if there are some empty end-pages */
  1892. if (vacuum_pages->vpl_empty_end_pages > 0)
  1893. {
  1894. Assert(vacrelstats->num_pages >= vacuum_pages->vpl_empty_end_pages);
  1895. nblocks = vacrelstats->num_pages - vacuum_pages->vpl_empty_end_pages;
  1896. elog(MESSAGE_LEVEL, "Rel %s: Pages: %u --> %u.",
  1897.  (RelationGetRelationName(onerel))->data,
  1898.  vacrelstats->num_pages, nblocks);
  1900. /*
  1901.  * we have to flush "empty" end-pages (if changed, but who knows
  1902.  * it) before truncation
  1903.  */
  1904. FlushBufferPool(!TransactionFlushEnabled());
  1906. i = BlowawayRelationBuffers(onerel, nblocks);
  1907. if (i < 0)
  1908. elog(FATAL, "VACUUM (vc_vacheap): BlowawayRelationBuffers returned %d", i);
  1910. nblocks = smgrtruncate(DEFAULT_SMGR, onerel, nblocks);
  1911. Assert(nblocks >= 0);
  1912. vacrelstats->num_pages = nblocks; /* set new number of
  1913.  * blocks */
  1914. }
  1916. } /* vc_vacheap */
  1918. /*
  1919.  * vc_vacpage() -- free dead tuples on a page
  1920.  *  and repaire its fragmentation.
  1921.  */
  1922. static void
  1923. vc_vacpage(Page page, VPageDescr vpd)
  1924. {
  1925. ItemId itemid;
  1926. int i;
  1928. for (i = 0; i < vpd->vpd_offsets_free; i++)
  1929. {
  1930. itemid = &(((PageHeader) page)->pd_linp[vpd->vpd_offsets[i] - 1]);
  1931. itemid->lp_flags &= ~LP_USED;
  1932. }
  1933. PageRepairFragmentation(page);
  1935. } /* vc_vacpage */
  1937. /*
  1938.  * _vc_scanoneind() -- scan one index relation to update statistic.
  1939.  *
  1940.  */
  1941. static void
  1942. vc_scanoneind(Relation indrel, int num_tuples)
  1943. {
  1944. RetrieveIndexResult res;
  1945. IndexScanDesc iscan;
  1946. int nitups;
  1947. int nipages;
  1948. struct rusage ru0,
  1949. ru1;
  1951. getrusage(RUSAGE_SELF, &ru0);
  1953. /* walk through the entire index */
  1954. iscan = index_beginscan(indrel, false, 0, (ScanKey) NULL);
  1955. nitups = 0;
  1957. while ((res = index_getnext(iscan, ForwardScanDirection))
  1958.    != (RetrieveIndexResult) NULL)
  1959. {
  1960. nitups++;
  1961. pfree(res);
  1962. }
  1964. index_endscan(iscan);
  1966. /* now update statistics in pg_class */
  1967. nipages = RelationGetNumberOfBlocks(indrel);
  1968. vc_updstats(RelationGetRelid(indrel), nipages, nitups, false, NULL);
  1970. getrusage(RUSAGE_SELF, &ru1);
  1972. elog(MESSAGE_LEVEL, "Index %s: Pages %u; Tuples %u. Elapsed %u/%u sec.",
  1973.  indrel->rd_rel->relname.data, nipages, nitups,
  1974.  ru1.ru_stime.tv_sec - ru0.ru_stime.tv_sec,
  1975.  ru1.ru_utime.tv_sec - ru0.ru_utime.tv_sec);
  1977. if (nitups != num_tuples)
  1978. elog(NOTICE, "Index %s: NUMBER OF INDEX' TUPLES (%u) IS NOT THE SAME AS HEAP' (%u)",
  1979.  indrel->rd_rel->relname.data, nitups, num_tuples);
  1981. } /* vc_scanoneind */
  1983. /*
  1984.  * vc_vaconeind() -- vacuum one index relation.
  1985.  *
  1986.  * Vpl is the VPageList of the heap we're currently vacuuming.
  1987.  * It's locked. Indrel is an index relation on the vacuumed heap.
  1988.  * We don't set locks on the index relation here, since the indexed
  1989.  * access methods support locking at different granularities.
  1990.  * We let them handle it.
  1991.  *
  1992.  * Finally, we arrange to update the index relation's statistics in
  1993.  * pg_class.
  1994.  */
  1995. static void
  1996. vc_vaconeind(VPageList vpl, Relation indrel, int num_tuples, int keep_tuples)
  1997. {
  1998. RetrieveIndexResult res;
  1999. IndexScanDesc iscan;
  2000. ItemPointer heapptr;
  2001. int tups_vacuumed;
  2002. int num_index_tuples;
  2003. int num_pages;
  2004. VPageDescr vp;
  2005. struct rusage ru0,
  2006. ru1;
  2008. getrusage(RUSAGE_SELF, &ru0);
  2010. /* walk through the entire index */
  2011. iscan = index_beginscan(indrel, false, 0, (ScanKey) NULL);
  2012. tups_vacuumed = 0;
  2013. num_index_tuples = 0;
  2015. while ((res = index_getnext(iscan, ForwardScanDirection))
  2016.    != (RetrieveIndexResult) NULL)
  2017. {
  2018. heapptr = &res->heap_iptr;
  2020. if ((vp = vc_tidreapped(heapptr, vpl)) != (VPageDescr) NULL)
  2021. {
  2022. #ifdef NOT_USED
  2023. elog(DEBUG, "<%x,%x> -> <%x,%x>",
  2024.  ItemPointerGetBlockNumber(&(res->index_iptr)),
  2025.  ItemPointerGetOffsetNumber(&(res->index_iptr)),
  2026.  ItemPointerGetBlockNumber(&(res->heap_iptr)),
  2027.  ItemPointerGetOffsetNumber(&(res->heap_iptr)));
  2028. #endif
  2029. if (vp->vpd_offsets_free == 0)
  2030. { /* this is EmptyPage !!! */
  2031. elog(NOTICE, "Index %s: pointer to EmptyPage (blk %u off %u) - fixing",
  2032.  indrel->rd_rel->relname.data,
  2033.  vp->vpd_blkno, ItemPointerGetOffsetNumber(heapptr));
  2034. }
  2035. ++tups_vacuumed;
  2036. index_delete(indrel, &res->index_iptr);
  2037. }
  2038. else
  2039. num_index_tuples++;
  2041. pfree(res);
  2042. }
  2044. index_endscan(iscan);
  2046. /* now update statistics in pg_class */
  2047. num_pages = RelationGetNumberOfBlocks(indrel);
  2048. vc_updstats(RelationGetRelid(indrel), num_pages, num_index_tuples, false, NULL);
  2050. getrusage(RUSAGE_SELF, &ru1);
  2052. elog(MESSAGE_LEVEL, "Index %s: Pages %u; Tuples %u: Deleted %u. Elapsed %u/%u sec.",
  2053.  indrel->rd_rel->relname.data, num_pages,
  2054.  num_index_tuples - keep_tuples, tups_vacuumed,
  2055.  ru1.ru_stime.tv_sec - ru0.ru_stime.tv_sec,
  2056.  ru1.ru_utime.tv_sec - ru0.ru_utime.tv_sec);
  2058. if (num_index_tuples != num_tuples + keep_tuples)
  2059. elog(NOTICE, "Index %s: NUMBER OF INDEX' TUPLES (%u) IS NOT THE SAME AS HEAP' (%u)",
  2060.  indrel->rd_rel->relname.data, num_index_tuples, num_tuples);
  2062. } /* vc_vaconeind */
  2064. /*
  2065.  * vc_tidreapped() -- is a particular tid reapped?
  2066.  *
  2067.  * vpl->VPageDescr_array is sorted in right order.
  2068.  */
  2069. static VPageDescr
  2070. vc_tidreapped(ItemPointer itemptr, VPageList vpl)
  2071. {
  2072. OffsetNumber ioffno;
  2073. OffsetNumber *voff;
  2074. VPageDescr vp,
  2075.    *vpp;
  2076. VPageDescrData vpd;
  2078. vpd.vpd_blkno = ItemPointerGetBlockNumber(itemptr);
  2079. ioffno = ItemPointerGetOffsetNumber(itemptr);
  2081. vp = &vpd;
  2082. vpp = (VPageDescr *) vc_find_eq((void *) (vpl->vpl_pagedesc),
  2083. vpl->vpl_num_pages, sizeof(VPageDescr), (void *) &vp,
  2084. vc_cmp_blk);
  2086. if (vpp == (VPageDescr *) NULL)
  2087. return (VPageDescr) NULL;
  2088. vp = *vpp;
  2090. /* ok - we are on true page */
  2092. if (vp->vpd_offsets_free == 0)
  2093. { /* this is EmptyPage !!! */
  2094. return vp;
  2095. }
  2097. voff = (OffsetNumber *) vc_find_eq((void *) (vp->vpd_offsets),
  2098. vp->vpd_offsets_free, sizeof(OffsetNumber), (void *) &ioffno,
  2099.    vc_cmp_offno);
  2101. if (voff == (OffsetNumber *) NULL)
  2102. return (VPageDescr) NULL;
  2104. return vp;
  2106. } /* vc_tidreapped */
  2108. /*
  2109.  * vc_attrstats() -- compute column statistics used by the optimzer
  2110.  *
  2111.  * We compute the column min, max, null and non-null counts.
  2112.  * Plus we attempt to find the count of the value that occurs most
  2113.  * frequently in each column
  2114.  * These figures are used to compute the selectivity of the column
  2115.  *
  2116.  * We use a three-bucked cache to get the most frequent item
  2117.  * The 'guess' buckets count hits.  A cache miss causes guess1
  2118.  * to get the most hit 'guess' item in the most recent cycle, and
  2119.  * the new item goes into guess2. Whenever the total count of hits
  2120.  * of a 'guess' entry is larger than 'best', 'guess' becomes 'best'.
  2121.  *
  2122.  * This method works perfectly for columns with unique values, and columns
  2123.  * with only two unique values, plus nulls.
  2124.  *
  2125.  * It becomes less perfect as the number of unique values increases and
  2126.  * their distribution in the table becomes more random.
  2127.  *
  2128.  */
  2129. static void
  2130. vc_attrstats(Relation onerel, VRelStats *vacrelstats, HeapTuple tuple)
  2131. {
  2132. int i,
  2133. attr_cnt = vacrelstats->va_natts;
  2134. VacAttrStats *vacattrstats = vacrelstats->vacattrstats;
  2135. TupleDesc tupDesc = onerel->rd_att;
  2136. Datum value;
  2137. bool isnull;
  2139. for (i = 0; i < attr_cnt; i++)
  2140. {
  2141. VacAttrStats *stats = &vacattrstats[i];
  2142. bool value_hit = true;
  2144. value = heap_getattr(tuple,
  2145.  stats->attr->attnum, tupDesc, &isnull);
  2147. if (!VacAttrStatsEqValid(stats))
  2148. continue;
  2150. if (isnull)
  2151. stats->null_cnt++;
  2152. else
  2153. {
  2154. stats->nonnull_cnt++;
  2155. if (stats->initialized == false)
  2156. {
  2157. vc_bucketcpy(stats->attr, value, &stats->best, &stats->best_len);
  2158. /* best_cnt gets incremented later */
  2159. vc_bucketcpy(stats->attr, value, &stats->guess1, &stats->guess1_len);
  2160. stats->guess1_cnt = stats->guess1_hits = 1;
  2161. vc_bucketcpy(stats->attr, value, &stats->guess2, &stats->guess2_len);
  2162. stats->guess2_hits = 1;
  2163. if (VacAttrStatsLtGtValid(stats))
  2164. {
  2165. vc_bucketcpy(stats->attr, value, &stats->max, &stats->max_len);
  2166. vc_bucketcpy(stats->attr, value, &stats->min, &stats->min_len);
  2167. }
  2168. stats->initialized = true;
  2169. }
  2170. if (VacAttrStatsLtGtValid(stats))
  2171. {
  2172. if ((*fmgr_faddr(&stats->f_cmplt)) (value, stats->min))
  2173. {
  2174. vc_bucketcpy(stats->attr, value, &stats->min, &stats->min_len);
  2175. stats->min_cnt = 0;
  2176. }
  2177. if ((*fmgr_faddr(&stats->f_cmpgt)) (value, stats->max))
  2178. {
  2179. vc_bucketcpy(stats->attr, value, &stats->max, &stats->max_len);
  2180. stats->max_cnt = 0;
  2181. }
  2182. if ((*fmgr_faddr(&stats->f_cmpeq)) (value, stats->min))
  2183. stats->min_cnt++;
  2184. else if ((*fmgr_faddr(&stats->f_cmpeq)) (value, stats->max))
  2185. stats->max_cnt++;
  2186. }
  2187. if ((*fmgr_faddr(&stats->f_cmpeq)) (value, stats->best))
  2188. stats->best_cnt++;
  2189. else if ((*fmgr_faddr(&stats->f_cmpeq)) (value, stats->guess1))
  2190. {
  2191. stats->guess1_cnt++;
  2192. stats->guess1_hits++;
  2193. }
  2194. else if ((*fmgr_faddr(&stats->f_cmpeq)) (value, stats->guess2))
  2195. stats->guess2_hits++;
  2196. else
  2197. value_hit = false;
  2199. if (stats->guess2_hits > stats->guess1_hits)
  2200. {
  2201. swapDatum(stats->guess1, stats->guess2);
  2202. swapInt(stats->guess1_len, stats->guess2_len);
  2203. stats->guess1_cnt = stats->guess2_hits;
  2204. swapLong(stats->guess1_hits, stats->guess2_hits);
  2205. }
  2206. if (stats->guess1_cnt > stats->best_cnt)
  2207. {
  2208. swapDatum(stats->best, stats->guess1);
  2209. swapInt(stats->best_len, stats->guess1_len);
  2210. swapLong(stats->best_cnt, stats->guess1_cnt);
  2211. stats->guess1_hits = 1;
  2212. stats->guess2_hits = 1;
  2213. }
  2214. if (!value_hit)
  2215. {
  2216. vc_bucketcpy(stats->attr, value, &stats->guess2, &stats->guess2_len);
  2217. stats->guess1_hits = 1;
  2218. stats->guess2_hits = 1;
  2219. }
  2220. }
  2221. }
  2222. return;
  2223. }
  2225. /*
  2226.  * vc_bucketcpy() -- update pg_class statistics for one relation
  2227.  *
  2228.  */
  2229. static void
  2230. vc_bucketcpy(Form_pg_attribute attr, Datum value, Datum *bucket, int16 *bucket_len)
  2231. {
  2232. if (attr->attbyval && attr->attlen != -1)
  2233. *bucket = value;
  2234. else
  2235. {
  2236. int len = (attr->attlen != -1 ? attr->attlen : VARSIZE(value));
  2238. if (len > *bucket_len)
  2239. {
  2240. if (*bucket_len != 0)
  2241. pfree(DatumGetPointer(*bucket));
  2242. *bucket = PointerGetDatum(palloc(len));
  2243. *bucket_len = len;
  2244. }
  2245. memmove(DatumGetPointer(*bucket), DatumGetPointer(value), len);
  2246. }
  2247. }
  2249. /*
  2250.  * vc_updstats() -- update pg_class statistics for one relation
  2251.  *
  2252.  * This routine works for both index and heap relation entries in
  2253.  * pg_class.  We violate no-overwrite semantics here by storing new
  2254.  * values for num_tuples, num_pages, and hasindex directly in the pg_class
  2255.  * tuple that's already on the page.  The reason for this is that if
  2256.  * we updated these tuples in the usual way, then every tuple in pg_class
  2257.  * would be replaced every day.  This would make planning and executing
  2258.  * historical queries very expensive. Note that we also don't use
  2259.  * any locking while doing updation.
  2260.  */
  2261. static void
  2262. vc_updstats(Oid relid, int num_pages, int num_tuples, bool hasindex, VRelStats *vacrelstats)
  2263. {
  2264. Relation rd,
  2265. ad,
  2266. sd;
  2267. HeapScanDesc scan;
  2268. HeapTupleData rtup;
  2269. HeapTuple ctup,
  2270. atup,
  2271. stup;
  2272. Form_pg_class pgcform;
  2273. ScanKeyData askey;
  2274. Form_pg_attribute attp;
  2275. Buffer buffer;
  2277. /*
  2278.  * update number of tuples and number of pages in pg_class
  2279.  */
  2280. ctup = SearchSysCacheTupleCopy(RELOID,
  2281.    ObjectIdGetDatum(relid),
  2282.    0, 0, 0);
  2283. if (!HeapTupleIsValid(ctup))
  2284. elog(ERROR, "pg_class entry for relid %u vanished during vacuuming",
  2285.  relid);
  2287. rd = heap_openr(RelationRelationName);
  2289. /* get the buffer cache tuple */
  2290. rtup.t_self = ctup->t_self;
  2291. heap_fetch(rd, SnapshotNow, &rtup, &buffer);
  2292. pfree(ctup);
  2294. /* overwrite the existing statistics in the tuple */
  2295. pgcform = (Form_pg_class) GETSTRUCT(&rtup);
  2296. pgcform->reltuples = num_tuples;
  2297. pgcform->relpages = num_pages;
  2298. pgcform->relhasindex = hasindex;
  2300. if (vacrelstats != NULL && vacrelstats->va_natts > 0)
  2301. {
  2302. VacAttrStats *vacattrstats = vacrelstats->vacattrstats;
  2303. int natts = vacrelstats->va_natts;
  2305. ad = heap_openr(AttributeRelationName);
  2306. sd = heap_openr(StatisticRelationName);
  2307. ScanKeyEntryInitialize(&askey, 0, Anum_pg_attribute_attrelid,
  2308.    F_INT4EQ, relid);
  2310. scan = heap_beginscan(ad, false, SnapshotNow, 1, &askey);
  2312. while (HeapTupleIsValid(atup = heap_getnext(scan, 0)))
  2313. {
  2314. int i;
  2315. float32data selratio; /* average ratio of rows selected
  2316.  * for a random constant */
  2317. VacAttrStats *stats;
  2318. Datum values[Natts_pg_statistic];
  2319. char nulls[Natts_pg_statistic];
  2321. attp = (Form_pg_attribute) GETSTRUCT(atup);
  2322. if (attp->attnum <= 0) /* skip system attributes for now, */
  2323. /* they are unique anyway */
  2324. continue;
  2326. for (i = 0; i < natts; i++)
  2327. {
  2328. if (attp->attnum == vacattrstats[i].attr->attnum)
  2329. break;
  2330. }
  2331. if (i >= natts)
  2332. continue;
  2333. stats = &(vacattrstats[i]);
  2335. /* overwrite the existing statistics in the tuple */
  2336. if (VacAttrStatsEqValid(stats))
  2337. {
  2338. if (stats->nonnull_cnt + stats->null_cnt == 0 ||
  2339. (stats->null_cnt <= 1 && stats->best_cnt == 1))
  2340. selratio = 0;
  2341. else if (VacAttrStatsLtGtValid(stats) && stats->min_cnt + stats->max_cnt == stats->nonnull_cnt)
  2342. {
  2343. double min_cnt_d = stats->min_cnt,
  2344. max_cnt_d = stats->max_cnt,
  2345. null_cnt_d = stats->null_cnt,
  2346. nonnullcnt_d = stats->nonnull_cnt; /* prevent overflow */
  2348. selratio = (min_cnt_d * min_cnt_d + max_cnt_d * max_cnt_d + null_cnt_d * null_cnt_d) /
  2349. (nonnullcnt_d + null_cnt_d) / (nonnullcnt_d + null_cnt_d);
  2350. }
  2351. else
  2352. {
  2353. double most = (double) (stats->best_cnt > stats->null_cnt ? stats->best_cnt : stats->null_cnt);
  2354. double total = ((double) stats->nonnull_cnt) + ((double) stats->null_cnt);
  2356. /*
  2357.  * we assume count of other values are 20% of best
  2358.  * count in table
  2359.  */
  2360. selratio = (most * most + 0.20 * most * (total - most)) / total / total;
  2361. }
  2362. if (selratio > 1.0)
  2363. selratio = 1.0;
  2364. attp->attdisbursion = selratio;
  2366. /*
  2367.  * Invalidate the cache for the tuple and write the buffer
  2368.  */
  2369. RelationInvalidateHeapTuple(ad, atup);
  2370. WriteNoReleaseBuffer(scan->rs_cbuf);
  2372. /* DO PG_STATISTIC INSERTS */
  2374. /*
  2375.  * doing system relations, especially pg_statistic is a
  2376.  * problem
  2377.  */
  2378. if (VacAttrStatsLtGtValid(stats) && stats->initialized /* &&
  2379.  * !IsSystemRelationName(
  2380.  *
  2381.  pgcform->relname.data) */ )
  2382. {
  2383. FmgrInfo out_function;
  2384. char    *out_string;
  2386. for (i = 0; i < Natts_pg_statistic; ++i)
  2387. nulls[i] = ' ';
  2389. /* ----------------
  2390.  * initialize values[]
  2391.  * ----------------
  2392.  */
  2393. i = 0;
  2394. values[i++] = (Datum) relid; /* 1 */
  2395. values[i++] = (Datum) attp->attnum; /* 2 */
  2396. values[i++] = (Datum) InvalidOid; /* 3 */
  2397. fmgr_info(stats->outfunc, &out_function);
  2398. out_string = (*fmgr_faddr(&out_function)) (stats->min, stats->attr->atttypid);
  2399. values[i++] = (Datum) fmgr(F_TEXTIN, out_string);
  2400. pfree(out_string);
  2401. out_string = (char *) (*fmgr_faddr(&out_function)) (stats->max, stats->attr->atttypid);
  2402. values[i++] = (Datum) fmgr(F_TEXTIN, out_string);
  2403. pfree(out_string);
  2405. stup = heap_formtuple(sd->rd_att, values, nulls);
  2407. /* ----------------
  2408.  * insert the tuple in the relation and get the tuple's oid.
  2409.  * ----------------
  2410.  */
  2411. heap_insert(sd, stup);
  2412. pfree(DatumGetPointer(values[3]));
  2413. pfree(DatumGetPointer(values[4]));
  2414. pfree(stup);
  2415. }
  2416. }
  2417. }
  2418. heap_endscan(scan);
  2419. heap_close(ad);
  2420. heap_close(sd);
  2421. }
  2423. /*
  2424.  * Invalidate the cached pg_class tuple and write the buffer
  2425.  */
  2426. RelationInvalidateHeapTuple(rd, &rtup);
  2428. WriteBuffer(buffer);
  2430. heap_close(rd);
  2431. }
  2433. /*
  2434.  * vc_delhilowstats() -- delete pg_statistics rows
  2435.  *
  2436.  */
  2437. static void
  2438. vc_delhilowstats(Oid relid, int attcnt, int *attnums)
  2439. {
  2440. Relation pgstatistic;
  2441. HeapScanDesc scan;
  2442. HeapTuple tuple;
  2443. ScanKeyData key;
  2445. pgstatistic = heap_openr(StatisticRelationName);
  2447. if (relid != InvalidOid)
  2448. {
  2449. ScanKeyEntryInitialize(&key, 0x0, Anum_pg_statistic_starelid,
  2450.    F_OIDEQ,
  2451.    ObjectIdGetDatum(relid));
  2452. scan = heap_beginscan(pgstatistic, false, SnapshotNow, 1, &key);
  2453. }
  2454. else
  2455. scan = heap_beginscan(pgstatistic, false, SnapshotNow, 0, NULL);
  2457. while (HeapTupleIsValid(tuple = heap_getnext(scan, 0)))
  2458. {
  2459. if (attcnt > 0)
  2460. {
  2461. Form_pg_statistic pgs = (Form_pg_statistic) GETSTRUCT(tuple);
  2462. int i;
  2464. for (i = 0; i < attcnt; i++)
  2465. {
  2466. if (pgs->staattnum == attnums[i] + 1)
  2467. break;
  2468. }
  2469. if (i >= attcnt)
  2470. continue; /* don't delete it */
  2471. }
  2472. heap_delete(pgstatistic, &tuple->t_self, NULL);
  2473. }
  2475. heap_endscan(scan);
  2476. heap_close(pgstatistic);
  2477. }
  2479. /*
  2480.  * vc_reappage() -- save a page on the array of reapped pages.
  2481.  *
  2482.  * As a side effect of the way that the vacuuming loop for a given
  2483.  * relation works, higher pages come after lower pages in the array
  2484.  * (and highest tid on a page is last).
  2485.  */
  2486. static void
  2487. vc_reappage(VPageList vpl, VPageDescr vpc)
  2488. {
  2489. VPageDescr newvpd;
  2491. /* allocate a VPageDescrData entry */
  2492. newvpd = (VPageDescr) palloc(sizeof(VPageDescrData) + vpc->vpd_offsets_free * sizeof(OffsetNumber));
  2494. /* fill it in */
  2495. if (vpc->vpd_offsets_free > 0)
  2496. memmove(newvpd->vpd_offsets, vpc->vpd_offsets, vpc->vpd_offsets_free * sizeof(OffsetNumber));
  2497. newvpd->vpd_blkno = vpc->vpd_blkno;
  2498. newvpd->vpd_free = vpc->vpd_free;
  2499. newvpd->vpd_offsets_used = vpc->vpd_offsets_used;
  2500. newvpd->vpd_offsets_free = vpc->vpd_offsets_free;
  2502. /* insert this page into vpl list */
  2503. vc_vpinsert(vpl, newvpd);
  2505. } /* vc_reappage */
  2507. static void
  2508. vc_vpinsert(VPageList vpl, VPageDescr vpnew)
  2509. {
  2510. #define PG_NPAGEDESC 1024
  2512. /* allocate a VPageDescr entry if needed */
  2513. if (vpl->vpl_num_pages == 0)
  2514. {
  2515. vpl->vpl_pagedesc = (VPageDescr *) palloc(PG_NPAGEDESC * sizeof(VPageDescr));
  2516. vpl->vpl_num_allocated_pages = PG_NPAGEDESC;
  2517. }
  2518. else if (vpl->vpl_num_pages >= vpl->vpl_num_allocated_pages)
  2519. {
  2520. vpl->vpl_num_allocated_pages *= 2;
  2521. vpl->vpl_pagedesc = (VPageDescr *) repalloc(vpl->vpl_pagedesc, vpl->vpl_num_allocated_pages * sizeof(VPageDescr));
  2522. }
  2523. vpl->vpl_pagedesc[vpl->vpl_num_pages] = vpnew;
  2524. (vpl->vpl_num_pages)++;
  2526. }
  2528. static void
  2529. vc_free(VRelList vrl)
  2530. {
  2531. VRelList p_vrl;
  2532. MemoryContext old;
  2533. PortalVariableMemory pmem;
  2535. pmem = PortalGetVariableMemory(vc_portal);
  2536. old = MemoryContextSwitchTo((MemoryContext) pmem);
  2538. while (vrl != (VRelList) NULL)
  2539. {
  2541. /* free rel list entry */
  2542. p_vrl = vrl;
  2543. vrl = vrl->vrl_next;
  2544. pfree(p_vrl);
  2545. }
  2547. MemoryContextSwitchTo(old);
  2548. }
  2550. static void *
  2551. vc_find_eq(void *bot, int nelem, int size, void *elm,
  2552.    int (*compar) (const void *, const void *))
  2553. {
  2554. int res;
  2555. int last = nelem - 1;
  2556. int celm = nelem / 2;
  2557. bool last_move,
  2558. first_move;
  2560. last_move = first_move = true;
  2561. for (;;)
  2562. {
  2563. if (first_move == true)
  2564. {
  2565. res = compar(bot, elm);
  2566. if (res > 0)
  2567. return NULL;
  2568. if (res == 0)
  2569. return bot;
  2570. first_move = false;
  2571. }
  2572. if (last_move == true)
  2573. {
  2574. res = compar(elm, (void *) ((char *) bot + last * size));
  2575. if (res > 0)
  2576. return NULL;
  2577. if (res == 0)
  2578. return (void *) ((char *) bot + last * size);
  2579. last_move = false;
  2580. }
  2581. res = compar(elm, (void *) ((char *) bot + celm * size));
  2582. if (res == 0)
  2583. return (void *) ((char *) bot + celm * size);
  2584. if (res < 0)
  2585. {
  2586. if (celm == 0)
  2587. return NULL;
  2588. last = celm - 1;
  2589. celm = celm / 2;
  2590. last_move = true;
  2591. continue;
  2592. }
  2594. if (celm == last)
  2595. return NULL;
  2597. last = last - celm - 1;
  2598. bot = (void *) ((char *) bot + (celm + 1) * size);
  2599. celm = (last + 1) / 2;
  2600. first_move = true;
  2601. }
  2603. } /* vc_find_eq */
  2605. static int
  2606. vc_cmp_blk(const void *left, const void *right)
  2607. {
  2608. BlockNumber lblk,
  2609. rblk;
  2611. lblk = (*((VPageDescr *) left))->vpd_blkno;
  2612. rblk = (*((VPageDescr *) right))->vpd_blkno;
  2614. if (lblk < rblk)
  2615. return -1;
  2616. if (lblk == rblk)
  2617. return 0;
  2618. return 1;
  2620. } /* vc_cmp_blk */
  2622. static int
  2623. vc_cmp_offno(const void *left, const void *right)
  2624. {
  2626. if (*(OffsetNumber *) left < *(OffsetNumber *) right)
  2627. return -1;
  2628. if (*(OffsetNumber *) left == *(OffsetNumber *) right)
  2629. return 0;
  2630. return 1;
  2632. } /* vc_cmp_offno */
  2634. static int
  2635. vc_cmp_vtlinks(const void *left, const void *right)
  2636. {
  2638. if (((VTupleLink) left)->new_tid.ip_blkid.bi_hi <
  2639. ((VTupleLink) right)->new_tid.ip_blkid.bi_hi)
  2640. return -1;
  2641. if (((VTupleLink) left)->new_tid.ip_blkid.bi_hi >
  2642. ((VTupleLink) right)->new_tid.ip_blkid.bi_hi)
  2643. return 1;
  2644. /* bi_hi-es are equal */
  2645. if (((VTupleLink) left)->new_tid.ip_blkid.bi_lo <
  2646. ((VTupleLink) right)->new_tid.ip_blkid.bi_lo)
  2647. return -1;
  2648. if (((VTupleLink) left)->new_tid.ip_blkid.bi_lo >
  2649. ((VTupleLink) right)->new_tid.ip_blkid.bi_lo)
  2650. return 1;
  2651. /* bi_lo-es are equal */
  2652. if (((VTupleLink) left)->new_tid.ip_posid <
  2653. ((VTupleLink) right)->new_tid.ip_posid)
  2654. return -1;
  2655. if (((VTupleLink) left)->new_tid.ip_posid >
  2656. ((VTupleLink) right)->new_tid.ip_posid)
  2657. return 1;
  2658. return 0;
  2660. }
  2662. static void
  2663. vc_getindices(Oid relid, int *nindices, Relation **Irel)
  2664. {
  2665. Relation pgindex;
  2666. Relation irel;
  2667. TupleDesc tupdesc;
  2668. HeapTuple tuple;
  2669. HeapScanDesc scan;
  2670. Datum d;
  2671. int i,
  2672. k;
  2673. bool n;
  2674. ScanKeyData key;
  2675. Oid    *ioid;
  2677. *nindices = i = 0;
  2679. ioid = (Oid *) palloc(10 * sizeof(Oid));
  2681. /* prepare a heap scan on the pg_index relation */
  2682. pgindex = heap_openr(IndexRelationName);
  2683. tupdesc = RelationGetDescr(pgindex);
  2685. ScanKeyEntryInitialize(&key, 0x0, Anum_pg_index_indrelid,
  2686.    F_OIDEQ,
  2687.    ObjectIdGetDatum(relid));
  2689. scan = heap_beginscan(pgindex, false, SnapshotNow, 1, &key);
  2691. while (HeapTupleIsValid(tuple = heap_getnext(scan, 0)))
  2692. {
  2693. d = heap_getattr(tuple, Anum_pg_index_indexrelid,
  2694.  tupdesc, &n);
  2695. i++;
  2696. if (i % 10 == 0)
  2697. ioid = (Oid *) repalloc(ioid, (i + 10) * sizeof(Oid));
  2698. ioid[i - 1] = DatumGetObjectId(d);
  2699. }
  2701. heap_endscan(scan);
  2702. heap_close(pgindex);
  2704. if (i == 0)
  2705. { /* No one index found */
  2706. pfree(ioid);
  2707. return;
  2708. }
  2710. if (Irel != (Relation **) NULL)
  2711. *Irel = (Relation *) palloc(i * sizeof(Relation));
  2713. for (k = 0; i > 0;)
  2714. {
  2715. irel = index_open(ioid[--i]);
  2716. if (irel != (Relation) NULL)
  2717. {
  2718. if (Irel != (Relation **) NULL)
  2719. (*Irel)[k] = irel;
  2720. else
  2721. index_close(irel);
  2722. k++;
  2723. }
  2724. else
  2725. elog(NOTICE, "CAN'T OPEN INDEX %u - SKIP IT", ioid[i]);
  2726. }
  2727. *nindices = k;
  2728. pfree(ioid);
  2730. if (Irel != (Relation **) NULL && *nindices == 0)
  2731. {
  2732. pfree(*Irel);
  2733. *Irel = (Relation *) NULL;
  2734. }
  2736. } /* vc_getindices */
  2739. static void
  2740. vc_clsindices(int nindices, Relation *Irel)
  2741. {
  2743. if (Irel == (Relation *) NULL)
  2744. return;
  2746. while (nindices--)
  2747. index_close(Irel[nindices]);
  2748. pfree(Irel);
  2750. } /* vc_clsindices */
  2753. static void
  2754. vc_mkindesc(Relation onerel, int nindices, Relation *Irel, IndDesc **Idesc)
  2755. {
  2756. IndDesc    *idcur;
  2757. HeapTuple cachetuple;
  2758. AttrNumber *attnumP;
  2759. int natts;
  2760. int i;
  2762. *Idesc = (IndDesc *) palloc(nindices * sizeof(IndDesc));
  2764. for (i = 0, idcur = *Idesc; i < nindices; i++, idcur++)
  2765. {
  2766. cachetuple = SearchSysCacheTupleCopy(INDEXRELID,
  2767.  ObjectIdGetDatum(RelationGetRelid(Irel[i])),
  2768.  0, 0, 0);
  2769. Assert(cachetuple);
  2771. /*
  2772.  * we never free the copy we make, because Idesc needs it for
  2773.  * later
  2774.  */
  2775. idcur->tform = (Form_pg_index) GETSTRUCT(cachetuple);
  2776. for (attnumP = &(idcur->tform->indkey[0]), natts = 0;
  2777.  natts < INDEX_MAX_KEYS && *attnumP != InvalidAttrNumber;
  2778.  attnumP++, natts++);
  2779. if (idcur->tform->indproc != InvalidOid)
  2780. {
  2781. idcur->finfoP = &(idcur->finfo);
  2782. FIgetnArgs(idcur->finfoP) = natts;
  2783. natts = 1;
  2784. FIgetProcOid(idcur->finfoP) = idcur->tform->indproc;
  2785. *(FIgetname(idcur->finfoP)) = '';
  2786. }
  2787. else
  2788. idcur->finfoP = (FuncIndexInfo *) NULL;
  2790. idcur->natts = natts;
  2791. }
  2793. } /* vc_mkindesc */
  2796. static bool
  2797. vc_enough_space(VPageDescr vpd, Size len)
  2798. {
  2800. len = MAXALIGN(len);
  2802. if (len > vpd->vpd_free)
  2803. return false;
  2805. if (vpd->vpd_offsets_used < vpd->vpd_offsets_free) /* there are free
  2806.  * itemid(s) */
  2807. return true; /* and len <= free_space */
  2809. /* ok. noff_usd >= noff_free and so we'll have to allocate new itemid */
  2810. if (len + MAXALIGN(sizeof(ItemIdData)) <= vpd->vpd_free)
  2811. return true;
  2813. return false;
  2815. } /* vc_enough_space */