Non-transactional pg_class, try 2

diff -rc -X diff-ignore 11fixclass/doc/src/sgml/catalogs.sgml 12ntrelminxid/doc/src/sgml/catalogs.sgml
*** 11fixclass/doc/src/sgml/catalogs.sgml	2006-06-09 18:52:50.000000000 -0400
--- 12ntrelminxid/doc/src/sgml/catalogs.sgml	2006-06-10 19:38:04.000000000 -0400
***************
*** 1619,1624 ****
--- 1619,1648 ----
       </row>
  
       <row>
+       <entry><structfield>relminxid</structfield></entry>
+       <entry><type>xid</type></entry>
+       <entry></entry>
+       <entry>
+        The minimum transaction ID present in all rows in this table.  This
+        value is used to determine the database-global
+        <structname>pg_database</>.<structfield>datminxid</> value.
+       </entry>
+      </row>
+ 
+      <row>
+       <entry><structfield>relvacuumxid</structfield></entry>
+       <entry><type>xid</type></entry>
+       <entry></entry>
+       <entry>
+        The transaction ID that was used as cleaning point as of the last vacuum
+        operation.  All rows inserted, updated or deleted in this table by
+        transactions whose IDs are below this one have been marked as known good
+        or deleted.  This is used to determine the database-global
+        <structname>pg_database</>.<structfield>datvacuumxid</> value.
+       </entry>
+      </row>
+ 
+      <row>
        <entry><structfield>relacl</structfield></entry>
        <entry><type>aclitem[]</type></entry>
        <entry></entry>
***************
*** 2048,2068 ****
        <entry><type>xid</type></entry>
        <entry></entry>
        <entry>
!        All rows inserted or deleted by transaction IDs before this one
!        have been marked as known committed or known aborted in this database.
!        This is used to determine when commit-log space can be recycled.
        </entry>
       </row>
  
       <row>
!       <entry><structfield>datfrozenxid</structfield></entry>
        <entry><type>xid</type></entry>
        <entry></entry>
        <entry>
         All rows inserted by transaction IDs before this one have been
         relabeled with a permanent (<quote>frozen</>) transaction ID in this
!        database.  This is useful to check whether a database must be vacuumed
!        soon to avoid transaction ID wrap-around problems.
        </entry>
       </row>
  
--- 2072,2098 ----
        <entry><type>xid</type></entry>
        <entry></entry>
        <entry>
!        The transaction ID that was used as cleaning point as of the last vacuum
!        operation.  All rows inserted or deleted by transaction IDs before this one
!        have been marked as known good or deleted.  This
!        is used to determine when commit-log space can be recycled.
!        If InvalidTransactionId, then the minimum is unknown and can be
!        determined by scanning <structname>pg_class</>.<structfield>relvacuumxid</>.
        </entry>
       </row>
  
       <row>
!       <entry><structfield>datminxid</structfield></entry>
        <entry><type>xid</type></entry>
        <entry></entry>
        <entry>
+        The minimum transaction ID present in all tables in this database.
         All rows inserted by transaction IDs before this one have been
         relabeled with a permanent (<quote>frozen</>) transaction ID in this
!        database.  This is useful to check whether a database must be
!        vacuumed soon to avoid transaction ID wrap-around problems.
!        If InvalidTransactionId, then the minimum is unknown and can be
!        determined by scanning <structname>pg_class</>.<structfield>relminxid</>.
        </entry>
       </row>
  
diff -rc -X diff-ignore 11fixclass/src/backend/access/heap/heapam.c 12ntrelminxid/src/backend/access/heap/heapam.c
*** 11fixclass/src/backend/access/heap/heapam.c	2006-06-10 19:17:47.000000000 -0400
--- 12ntrelminxid/src/backend/access/heap/heapam.c	2006-06-11 02:41:15.000000000 -0400
***************
*** 45,61 ****
--- 45,74 ----
  #include "access/valid.h"
  #include "access/xlogutils.h"
  #include "catalog/catalog.h"
+ #include "catalog/heap.h"
  #include "catalog/namespace.h"
+ #include "catalog/pg_ntclass.h"
  #include "miscadmin.h"
  #include "pgstat.h"
  #include "storage/procarray.h"
  #include "utils/inval.h"
  #include "utils/relcache.h"
+ #include "utils/syscache.h"
  
  
  static XLogRecPtr log_heap_update(Relation reln, Buffer oldbuf,
  		   ItemPointerData from, Buffer newbuf, HeapTuple newtup, bool move);
  
+ /*
+  * There are some situations in which we want to acquire strong locks on
+  * relations, but we know there is no need to unfreeze them; for example,
+  * during VACUUM.  Any such caller sets this variable to true, which turns
+  * heap_unfreeze into a no-op.
+  *
+  * It's advisable to do this in a PG_TRY block so that it won't "forget" to
+  * reset the variable in case of error.
+  */
+ bool	disable_heap_unfreeze = false;
  
  /* ----------------------------------------------------------------
   *						 heap support routines
***************
*** 2669,2674 ****
--- 2682,2772 ----
  	return HeapTupleMayBeUpdated;
  }
  
+ /*
+  * heap_unfreeze
+  * 		Mark a table as no longer frozen in pg_ntclass.
+  *
+  * This routine updates the pg_ntclass.relminxid and relvacuumxid columns so
+  * that they no longer appear as frozen.
+  */
+ void
+ heap_unfreeze(Relation rel)
+ {
+ 	Form_pg_ntclass	ntclassForm;
+ 	HeapTuple		tuple;
+ 	bool			dirty = false;
+ 
+ 	/* early exit if somebody decided to disable us */
+ 	if (disable_heap_unfreeze)
+ 		return;
+ 
+ 	/* Exit early in bootstrap mode */
+ 	if (IsBootstrapProcessingMode())
+ 		return;
+ 
+ 	/*
+ 	 * We process only normal heaps, toast tables, and non-transactional
+ 	 * heaps.  Other kinds of heaps don't store Xids in them and thus they
+ 	 * don't need unfreezing.
+ 	 */
+ 	if (rel->rd_rel->relkind != RELKIND_RELATION &&
+ 		rel->rd_rel->relkind != RELKIND_INDEX &&
+ 		rel->rd_rel->relkind != RELKIND_NON_TRANSACTIONAL)
+ 		return;
+ 
+ 	/*
+ 	 * Under normal conditions, we should have a snapshot already, but in some
+ 	 * cases there may not be one.  Getting a snapshot guarantees we will have
+ 	 * a valid RecentXmin to use.
+ 	 */
+ 	if (!TransactionIdIsValid(RecentXmin))
+ 		ActiveSnapshot = CopySnapshot(GetTransactionSnapshot());
+ 	Assert(TransactionIdIsValid(RecentXmin));
+ 
+ 	PG_TRY();
+ 	{
+ 		Relation	pg_ntclass;
+ 
+ 		/* Disable ourselves so that we don't recurse on unfreezing pg_ntclass */
+ 		disable_heap_unfreeze = true;
+ 
+ 		pg_ntclass = heap_open(NtClassRelationId, RowExclusiveLock);
+ 
+ 		/* Fetch a copy to scribble on */
+ 		tuple = get_ntclass_entry(pg_ntclass, rel);
+ 
+ 		ntclassForm = (Form_pg_ntclass) GETSTRUCT(tuple);
+ 
+ 		/* Apply all necessary updates. */
+ 		if (TransactionIdEquals(ntclassForm->relminxid, FrozenTransactionId))
+ 		{
+ 			ntclassForm->relminxid = RecentXmin;
+ 			dirty = true;
+ 		}
+ 		if (TransactionIdEquals(ntclassForm->relvacuumxid, FrozenTransactionId))
+ 		{
+ 			ntclassForm->relvacuumxid = RecentXmin;
+ 			dirty = true;
+ 		}
+ 		/* Update tuple if necessary. */
+ 		if (dirty)
+ 			update_ntclass_entry(pg_ntclass, tuple);
+ 
+ 		/* All done, cleanup and return */
+ 		heap_freetuple(tuple);
+ 		heap_close(pg_ntclass, RowExclusiveLock);
+ 
+ 		/* reenable heap unfreezing */
+ 		disable_heap_unfreeze = false;
+ 	}
+ 	PG_CATCH();
+ 	{
+ 		/* make sure to reenable heap unfreezing in case of error */
+ 		disable_heap_unfreeze = false;
+ 		PG_RE_THROW();
+ 	}
+ 	PG_END_TRY();
+ }
  
  /*
   * heap_inplace_update - update a tuple "in place" (ie, overwrite it)
diff -rc -X diff-ignore 11fixclass/src/backend/access/transam/varsup.c 12ntrelminxid/src/backend/access/transam/varsup.c
*** 11fixclass/src/backend/access/transam/varsup.c	2006-03-08 16:23:24.000000000 -0300
--- 12ntrelminxid/src/backend/access/transam/varsup.c	2006-06-10 19:38:04.000000000 -0400
***************
*** 168,178 ****
  
  /*
   * Determine the last safe XID to allocate given the currently oldest
!  * datfrozenxid (ie, the oldest XID that might exist in any database
   * of our cluster).
   */
  void
! SetTransactionIdLimit(TransactionId oldest_datfrozenxid,
  					  Name oldest_datname)
  {
  	TransactionId xidWarnLimit;
--- 168,178 ----
  
  /*
   * Determine the last safe XID to allocate given the currently oldest
!  * datminxid (ie, the oldest XID that might exist in any database
   * of our cluster).
   */
  void
! SetTransactionIdLimit(TransactionId oldest_datminxid,
  					  Name oldest_datname)
  {
  	TransactionId xidWarnLimit;
***************
*** 180,195 ****
  	TransactionId xidWrapLimit;
  	TransactionId curXid;
  
! 	Assert(TransactionIdIsValid(oldest_datfrozenxid));
  
  	/*
  	 * The place where we actually get into deep trouble is halfway around
! 	 * from the oldest potentially-existing XID.  (This calculation is
! 	 * probably off by one or two counts, because the special XIDs reduce the
! 	 * size of the loop a little bit.  But we throw in plenty of slop below,
! 	 * so it doesn't matter.)
  	 */
! 	xidWrapLimit = oldest_datfrozenxid + (MaxTransactionId >> 1);
  	if (xidWrapLimit < FirstNormalTransactionId)
  		xidWrapLimit += FirstNormalTransactionId;
  
--- 180,195 ----
  	TransactionId xidWrapLimit;
  	TransactionId curXid;
  
! 	Assert(TransactionIdIsValid(oldest_datminxid));
  
  	/*
  	 * The place where we actually get into deep trouble is halfway around
! 	 * from the oldest existing XID.  (This calculation is probably off by one
! 	 * or two counts, because the special XIDs reduce the size of the loop a
! 	 * little bit.  But we throw in plenty of slop below, so it doesn't
! 	 * matter.)
  	 */
! 	xidWrapLimit = oldest_datminxid + (MaxTransactionId >> 1);
  	if (xidWrapLimit < FirstNormalTransactionId)
  		xidWrapLimit += FirstNormalTransactionId;
  
diff -rc -X diff-ignore 11fixclass/src/backend/catalog/heap.c 12ntrelminxid/src/backend/catalog/heap.c
*** 11fixclass/src/backend/catalog/heap.c	2006-06-11 02:46:03.000000000 -0400
--- 12ntrelminxid/src/backend/catalog/heap.c	2006-06-11 01:03:39.000000000 -0400
***************
*** 637,648 ****
  		switch (relkind)
  		{
  			case RELKIND_RELATION:
- 			case RELKIND_INDEX:
  			case RELKIND_TOASTVALUE:
  			case RELKIND_NON_TRANSACTIONAL:
  				/* The relation is real, but as yet empty */
  				new_rel_nttup->relpages = 0;
  				new_rel_nttup->reltuples = 0;
  				break;
  			default:
  				elog(ERROR, "can't create pg_ntclass entries for relkind '%c'",
--- 637,665 ----
  		switch (relkind)
  		{
  			case RELKIND_RELATION:
  			case RELKIND_TOASTVALUE:
  			case RELKIND_NON_TRANSACTIONAL:
  				/* The relation is real, but as yet empty */
  				new_rel_nttup->relpages = 0;
  				new_rel_nttup->reltuples = 0;
+ 				/*
+ 				 * Real tables have Xids stored in them, so initialize our
+ 				 * known value to the minimum Xid that could put tuples in the
+ 				 * new table.
+ 				 */
+ 				new_rel_nttup->relminxid = RecentXmin;
+ 				new_rel_nttup->relvacuumxid = RecentXmin;
+ 				break;
+ 			case RELKIND_INDEX:
+ 				/* The relation is real, but as yet empty */
+ 				new_rel_nttup->relpages = 0;
+ 				new_rel_nttup->reltuples = 0;
+ 				/*
+ 				 * Index relations don't have Xids stored in them, so set the
+ 				 * transaction Id values to InvalidTransactionId.
+ 				 */
+ 				new_rel_nttup->relminxid = InvalidTransactionId;
+ 				new_rel_nttup->relvacuumxid = InvalidTransactionId;
  				break;
  			default:
  				elog(ERROR, "can't create pg_ntclass entries for relkind '%c'",
diff -rc -X diff-ignore 11fixclass/src/backend/commands/analyze.c 12ntrelminxid/src/backend/commands/analyze.c
*** 11fixclass/src/backend/commands/analyze.c	2006-06-10 19:17:47.000000000 -0400
--- 12ntrelminxid/src/backend/commands/analyze.c	2006-06-11 01:26:00.000000000 -0400
***************
*** 420,426 ****
  
  	/*
  	 * If we are running a standalone ANALYZE, update pages/tuples stats in
! 	 * pg_class.  We know the accurate page count from the smgr, but only an
  	 * approximate number of tuples; therefore, if we are part of VACUUM
  	 * ANALYZE do *not* overwrite the accurate count already inserted by
  	 * VACUUM.	The same consideration applies to indexes.
--- 420,426 ----
  
  	/*
  	 * If we are running a standalone ANALYZE, update pages/tuples stats in
! 	 * pg_ntclass.  We know the accurate page count from the smgr, but only an
  	 * approximate number of tuples; therefore, if we are part of VACUUM
  	 * ANALYZE do *not* overwrite the accurate count already inserted by
  	 * VACUUM.	The same consideration applies to indexes.
***************
*** 429,436 ****
  	{
  		vac_update_relstats(onerel,
  							RelationGetNumberOfBlocks(onerel),
! 							totalrows,
! 							hasindex);
  		for (ind = 0; ind < nindexes; ind++)
  		{
  			AnlIndexData *thisdata = &indexdata[ind];
--- 429,437 ----
  	{
  		vac_update_relstats(onerel,
  							RelationGetNumberOfBlocks(onerel),
! 							totalrows, hasindex,
! 							InvalidTransactionId, InvalidTransactionId);
! 
  		for (ind = 0; ind < nindexes; ind++)
  		{
  			AnlIndexData *thisdata = &indexdata[ind];
***************
*** 439,446 ****
  			totalindexrows = ceil(thisdata->tupleFract * totalrows);
  			vac_update_relstats(Irel[ind],
  								RelationGetNumberOfBlocks(Irel[ind]),
! 								totalindexrows,
! 								false);
  		}
  
  		/* report results to the stats collector, too */
--- 440,447 ----
  			totalindexrows = ceil(thisdata->tupleFract * totalrows);
  			vac_update_relstats(Irel[ind],
  								RelationGetNumberOfBlocks(Irel[ind]),
! 								totalindexrows, false,
! 								InvalidTransactionId, InvalidTransactionId);
  		}
  
  		/* report results to the stats collector, too */
diff -rc -X diff-ignore 11fixclass/src/backend/commands/dbcommands.c 12ntrelminxid/src/backend/commands/dbcommands.c
*** 11fixclass/src/backend/commands/dbcommands.c	2006-05-04 21:36:10.000000000 -0400
--- 12ntrelminxid/src/backend/commands/dbcommands.c	2006-06-10 19:38:04.000000000 -0400
***************
*** 46,51 ****
--- 46,52 ----
  #include "utils/flatfiles.h"
  #include "utils/fmgroids.h"
  #include "utils/guc.h"
+ #include "utils/inval.h"
  #include "utils/lsyscache.h"
  #include "utils/syscache.h"
  
***************
*** 55,61 ****
  			Oid *dbIdP, Oid *ownerIdP,
  			int *encodingP, bool *dbIsTemplateP, bool *dbAllowConnP,
  			Oid *dbLastSysOidP,
! 			TransactionId *dbVacuumXidP, TransactionId *dbFrozenXidP,
  			Oid *dbTablespace);
  static bool have_createdb_privilege(void);
  static void remove_dbtablespaces(Oid db_id);
--- 56,62 ----
  			Oid *dbIdP, Oid *ownerIdP,
  			int *encodingP, bool *dbIsTemplateP, bool *dbAllowConnP,
  			Oid *dbLastSysOidP,
! 			TransactionId *dbVacuumXidP, TransactionId *dbMinXidP,
  			Oid *dbTablespace);
  static bool have_createdb_privilege(void);
  static void remove_dbtablespaces(Oid db_id);
***************
*** 76,82 ****
  	bool		src_allowconn;
  	Oid			src_lastsysoid;
  	TransactionId src_vacuumxid;
! 	TransactionId src_frozenxid;
  	Oid			src_deftablespace;
  	volatile Oid dst_deftablespace;
  	Relation	pg_database_rel;
--- 77,83 ----
  	bool		src_allowconn;
  	Oid			src_lastsysoid;
  	TransactionId src_vacuumxid;
! 	TransactionId src_minxid;
  	Oid			src_deftablespace;
  	volatile Oid dst_deftablespace;
  	Relation	pg_database_rel;
***************
*** 228,234 ****
  	if (!get_db_info(dbtemplate, ShareLock,
  					 &src_dboid, &src_owner, &src_encoding,
  					 &src_istemplate, &src_allowconn, &src_lastsysoid,
! 					 &src_vacuumxid, &src_frozenxid, &src_deftablespace))
  		ereport(ERROR,
  				(errcode(ERRCODE_UNDEFINED_DATABASE),
  				 errmsg("template database \"%s\" does not exist",
--- 229,235 ----
  	if (!get_db_info(dbtemplate, ShareLock,
  					 &src_dboid, &src_owner, &src_encoding,
  					 &src_istemplate, &src_allowconn, &src_lastsysoid,
! 					 &src_vacuumxid, &src_minxid, &src_deftablespace))
  		ereport(ERROR,
  				(errcode(ERRCODE_UNDEFINED_DATABASE),
  				 errmsg("template database \"%s\" does not exist",
***************
*** 327,340 ****
  	}
  
  	/*
! 	 * Normally we mark the new database with the same datvacuumxid and
! 	 * datfrozenxid as the source.	However, if the source is not allowing
! 	 * connections then we assume it is fully frozen, and we can set the
! 	 * current transaction ID as the xid limits.  This avoids immediately
! 	 * starting to generate warnings after cloning template0.
! 	 */
! 	if (!src_allowconn)
! 		src_vacuumxid = src_frozenxid = GetCurrentTransactionId();
  
  	/*
  	 * Check for db name conflict.	This is just to give a more friendly
--- 328,342 ----
  	}
  
  	/*
! 	 * Normally we mark the new database with the same datminxid as the source.
! 	 * However, if the source is fully frozen, we must not mark the new
! 	 * database as frozen because of the new pg_database tuple, which will be
! 	 * marked with our transaction ID.
! 	 */
! 	if (TransactionIdEquals(src_minxid, FrozenTransactionId))
! 		src_minxid = GetCurrentTransactionId();
! 	if (TransactionIdEquals(src_vacuumxid, FrozenTransactionId))
! 		src_vacuumxid = GetCurrentTransactionId();
  
  	/*
  	 * Check for db name conflict.	This is just to give a more friendly
***************
*** 367,373 ****
  	new_record[Anum_pg_database_datconnlimit - 1] = Int32GetDatum(dbconnlimit);
  	new_record[Anum_pg_database_datlastsysoid - 1] = ObjectIdGetDatum(src_lastsysoid);
  	new_record[Anum_pg_database_datvacuumxid - 1] = TransactionIdGetDatum(src_vacuumxid);
! 	new_record[Anum_pg_database_datfrozenxid - 1] = TransactionIdGetDatum(src_frozenxid);
  	new_record[Anum_pg_database_dattablespace - 1] = ObjectIdGetDatum(dst_deftablespace);
  
  	/*
--- 369,375 ----
  	new_record[Anum_pg_database_datconnlimit - 1] = Int32GetDatum(dbconnlimit);
  	new_record[Anum_pg_database_datlastsysoid - 1] = ObjectIdGetDatum(src_lastsysoid);
  	new_record[Anum_pg_database_datvacuumxid - 1] = TransactionIdGetDatum(src_vacuumxid);
! 	new_record[Anum_pg_database_datminxid - 1] = TransactionIdGetDatum(src_minxid);
  	new_record[Anum_pg_database_dattablespace - 1] = ObjectIdGetDatum(dst_deftablespace);
  
  	/*
***************
*** 1050,1055 ****
--- 1052,1119 ----
  	 */
  }
  
+ /*
+  * UnfreezeDatabase
+  *		Unfreezes a database
+  *
+  * Unfreezing a database is to set datminxid and datvacuumxid to a current
+  * normal Xid.  Currently, we do this anytime somebody connects to a database
+  * that is currently marked as frozen (datminxid = FrozenTransactionId).
+  *
+  * NB --- this is called early during backend initialization.
+  */
+ void
+ UnfreezeDatabase(Oid dbid, TransactionId unfreezeXid)
+ {
+ 	Relation	dbRel;
+ 	HeapTuple	tuple;
+ 	Form_pg_database dbForm;
+ 	bool		dirty = false;
+ 
+ 	PG_TRY();
+ 	{
+ 		disable_heap_unfreeze = true;
+ 
+ 		dbRel = heap_open(DatabaseRelationId, RowExclusiveLock);
+ 
+ 		/* fetch a copy of the tuple to scribble on */
+ 		tuple = SearchSysCacheCopy(DATABASEOID,
+ 								   dbid,
+ 								   0, 0, 0);
+ 
+ 		if (!HeapTupleIsValid(tuple))
+ 			elog(ERROR,
+ 				 "cache lookup failed for database %u", dbid);
+ 
+ 		dbForm = (Form_pg_database) GETSTRUCT(tuple);
+ 
+ 		/* make sure no one did it while we weren't looking */
+ 		if (TransactionIdEquals(dbForm->datminxid, FrozenTransactionId))
+ 		{
+ 			dbForm->datminxid = unfreezeXid;
+ 			dirty = true;
+ 		}
+ 		if (TransactionIdEquals(dbForm->datvacuumxid, FrozenTransactionId))
+ 		{
+ 			dbForm->datvacuumxid = unfreezeXid;
+ 			dirty = true;
+ 		}
+ 
+ 		if (dirty)
+ 			heap_inplace_update(dbRel, tuple);
+ 
+ 		heap_close(dbRel, RowExclusiveLock);
+ 	}
+ 	PG_CATCH();
+ 	{
+ 		disable_heap_unfreeze = false;
+ 		PG_RE_THROW();
+ 	};
+ 	PG_END_TRY();
+ 
+ 	/* reenable heap unfreezing */
+ 	disable_heap_unfreeze = false;
+ }
  
  /*
   * Helper functions
***************
*** 1066,1072 ****
  			Oid *dbIdP, Oid *ownerIdP,
  			int *encodingP, bool *dbIsTemplateP, bool *dbAllowConnP,
  			Oid *dbLastSysOidP,
! 			TransactionId *dbVacuumXidP, TransactionId *dbFrozenXidP,
  			Oid *dbTablespace)
  {
  	bool		result = false;
--- 1130,1136 ----
  			Oid *dbIdP, Oid *ownerIdP,
  			int *encodingP, bool *dbIsTemplateP, bool *dbAllowConnP,
  			Oid *dbLastSysOidP,
! 			TransactionId *dbVacuumXidP, TransactionId *dbMinXidP,
  			Oid *dbTablespace)
  {
  	bool		result = false;
***************
*** 1155,1163 ****
  				/* limit of vacuumed XIDs */
  				if (dbVacuumXidP)
  					*dbVacuumXidP = dbform->datvacuumxid;
! 				/* limit of frozen XIDs */
! 				if (dbFrozenXidP)
! 					*dbFrozenXidP = dbform->datfrozenxid;
  				/* default tablespace for this database */
  				if (dbTablespace)
  					*dbTablespace = dbform->dattablespace;
--- 1219,1227 ----
  				/* limit of vacuumed XIDs */
  				if (dbVacuumXidP)
  					*dbVacuumXidP = dbform->datvacuumxid;
! 				/* limit of min XIDs */
! 				if (dbMinXidP)
! 					*dbMinXidP = dbform->datminxid;
  				/* default tablespace for this database */
  				if (dbTablespace)
  					*dbTablespace = dbform->dattablespace;
diff -rc -X diff-ignore 11fixclass/src/backend/commands/vacuum.c 12ntrelminxid/src/backend/commands/vacuum.c
*** 11fixclass/src/backend/commands/vacuum.c	2006-06-10 19:17:47.000000000 -0400
--- 12ntrelminxid/src/backend/commands/vacuum.c	2006-06-11 02:37:38.000000000 -0400
***************
*** 129,134 ****
--- 129,135 ----
  	Size		min_tlen;
  	Size		max_tlen;
  	bool		hasindex;
+ 	TransactionId minxid;	/* Minimum Xid present anywhere on table */
  	/* vtlinks array for tuple chain following - sorted by new_tid */
  	int			num_vtlinks;
  	VTupleLink	vtlinks;
***************
*** 196,220 ****
  
  static int	elevel = -1;
  
- static TransactionId OldestXmin;
- static TransactionId FreezeLimit;
- 
  
  /* non-export function prototypes */
  static List *get_rel_oids(List *relids, const RangeVar *vacrel,
  			 const char *stmttype, bool full);
! static void vac_update_dbstats(Oid dbid,
! 				   TransactionId vacuumXID,
! 				   TransactionId frozenXID);
! static void vac_truncate_clog(TransactionId vacuumXID,
! 				  TransactionId frozenXID);
! static bool vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool allow_toast);
  static void full_vacuum_rel(Relation onerel, VacuumStmt *vacstmt);
  static void scan_heap(VRelStats *vacrelstats, Relation onerel,
! 		  VacPageList vacuum_pages, VacPageList fraged_pages);
  static void repair_frag(VRelStats *vacrelstats, Relation onerel,
  			VacPageList vacuum_pages, VacPageList fraged_pages,
! 			int nindexes, Relation *Irel);
  static void move_chain_tuple(Relation rel,
  				 Buffer old_buf, Page old_page, HeapTuple old_tup,
  				 Buffer dst_buf, Page dst_page, VacPage dst_vacpage,
--- 197,216 ----
  
  static int	elevel = -1;
  
  
  /* non-export function prototypes */
  static List *get_rel_oids(List *relids, const RangeVar *vacrel,
  			 const char *stmttype, bool full);
! static void vac_update_dbminxid(Oid dbid);
! static void vac_truncate_clog(void);
! static void vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool allow_toast);
  static void full_vacuum_rel(Relation onerel, VacuumStmt *vacstmt);
  static void scan_heap(VRelStats *vacrelstats, Relation onerel,
! 		  VacPageList vacuum_pages, VacPageList fraged_pages,
! 		  TransactionId FreezeLimit, TransactionId OldestXmin);
  static void repair_frag(VRelStats *vacrelstats, Relation onerel,
  			VacPageList vacuum_pages, VacPageList fraged_pages,
! 			int nindexes, Relation *Irel, TransactionId OldestXmin);
  static void move_chain_tuple(Relation rel,
  				 Buffer old_buf, Page old_page, HeapTuple old_tup,
  				 Buffer dst_buf, Page dst_page, VacPage dst_vacpage,
***************
*** 270,277 ****
  vacuum(VacuumStmt *vacstmt, List *relids)
  {
  	const char *stmttype = vacstmt->vacuum ? "VACUUM" : "ANALYZE";
- 	TransactionId initialOldestXmin = InvalidTransactionId;
- 	TransactionId initialFreezeLimit = InvalidTransactionId;
  	volatile MemoryContext anl_context = NULL;
  	volatile bool all_rels,
  				in_outer_xact,
--- 266,271 ----
***************
*** 355,386 ****
  	relations = get_rel_oids(relids, vacstmt->relation, stmttype,
  		   					 vacstmt->full);
  
- 	if (vacstmt->vacuum && all_rels)
- 	{
- 		/*
- 		 * It's a database-wide VACUUM.
- 		 *
- 		 * Compute the initially applicable OldestXmin and FreezeLimit XIDs,
- 		 * so that we can record these values at the end of the VACUUM. Note
- 		 * that individual tables may well be processed with newer values, but
- 		 * we can guarantee that no (non-shared) relations are processed with
- 		 * older ones.
- 		 *
- 		 * It is okay to record non-shared values in pg_database, even though
- 		 * we may vacuum shared relations with older cutoffs, because only the
- 		 * minimum of the values present in pg_database matters.  We can be
- 		 * sure that shared relations have at some time been vacuumed with
- 		 * cutoffs no worse than the global minimum; for, if there is a
- 		 * backend in some other DB with xmin = OLDXMIN that's determining the
- 		 * cutoff with which we vacuum shared relations, it is not possible
- 		 * for that database to have a cutoff newer than OLDXMIN recorded in
- 		 * pg_database.
- 		 */
- 		vacuum_set_xid_limits(vacstmt, false,
- 							  &initialOldestXmin,
- 							  &initialFreezeLimit);
- 	}
- 
  	/*
  	 * Decide whether we need to start/commit our own transactions.
  	 *
--- 349,354 ----
***************
*** 441,446 ****
--- 409,424 ----
  		VacuumCostBalance = 0;
  
  		/*
+ 		 * During vacuum, we are going to lock the relation with a writer's
+ 		 * lock, but if it's already frozen, we won't do any writing on it, so
+ 		 * disable the unfreezing for the duration of this VACUUM operation.
+ 		 * However, if this a FULL vacuum, we may mark some tuples with our
+ 		 * Xid even if the table is frozen, so skip this step.
+ 		 */
+ 		if (!vacstmt->full)
+ 	   		disable_heap_unfreeze = true;
+ 
+ 		/*
  		 * Loop to process each selected relation.
  		 */
  		foreach(cur, relations)
***************
*** 448,457 ****
  			Oid			relid = lfirst_oid(cur);
  
  			if (vacstmt->vacuum)
! 			{
! 				if (!vacuum_rel(relid, vacstmt, false))
! 					all_rels = false;	/* forget about updating dbstats */
! 			}
  			if (vacstmt->analyze)
  			{
  				MemoryContext old_context = NULL;
--- 426,433 ----
  			Oid			relid = lfirst_oid(cur);
  
  			if (vacstmt->vacuum)
! 				vacuum_rel(relid, vacstmt, false);
! 
  			if (vacstmt->analyze)
  			{
  				MemoryContext old_context = NULL;
***************
*** 496,507 ****
--- 472,487 ----
  	{
  		/* Make sure cost accounting is turned off after error */
  		VacuumCostActive = false;
+ 		/* reenable heap unfreezing too */
+ 		disable_heap_unfreeze = false;
  		PG_RE_THROW();
  	}
  	PG_END_TRY();
  
  	/* Turn off vacuum cost accounting */
  	VacuumCostActive = false;
+ 	/* reenable heap unfreezing too */
+ 	disable_heap_unfreeze = false;
  
  	/*
  	 * Finish up processing.
***************
*** 534,550 ****
  		if (all_rels)
  			PrintFreeSpaceMapStatistics(elevel);
  
! 		/*
! 		 * If we completed a database-wide VACUUM without skipping any
! 		 * relations, update the database's pg_database row with info about
! 		 * the transaction IDs used, and try to truncate pg_clog.
! 		 */
! 		if (all_rels)
! 		{
! 			vac_update_dbstats(MyDatabaseId,
! 							   initialOldestXmin, initialFreezeLimit);
! 			vac_truncate_clog(initialOldestXmin, initialFreezeLimit);
! 		}
  	}
  
  	/*
--- 514,524 ----
  		if (all_rels)
  			PrintFreeSpaceMapStatistics(elevel);
  
! 		/* Update pg_database.datminxid and datvacuumxid */
! 		vac_update_dbminxid(MyDatabaseId);
! 
! 		/* Try to truncate pg_clog. */
! 		vac_truncate_clog();
  	}
  
  	/*
***************
*** 701,707 ****
   */
  void
  vac_update_relstats(Relation rel, BlockNumber num_pages, double num_tuples,
! 					bool hasindex)
  {
  	Relation	rd;
  	HeapTuple	ctup;
--- 675,682 ----
   */
  void
  vac_update_relstats(Relation rel, BlockNumber num_pages, double num_tuples,
! 					bool hasindex, TransactionId minxid,
! 					TransactionId vacuumxid)
  {
  	Relation	rd;
  	HeapTuple	ctup;
***************
*** 709,832 ****
  	Form_pg_class pgcform;
  	bool		dirty;
  
! 	/* Process pg_ntclass first */
! 	rd = heap_open(NtClassRelationId, RowExclusiveLock);
  
! 	/* Fetch a copy of the pg_ntclass tuple to scribble on */
! 	ctup = get_ntclass_entry(rd, rel);
  
! 	pgntform = (Form_pg_ntclass) GETSTRUCT(ctup);
  
! 	/* Apply required updates, if any, to copied tuple */
  
! 	dirty = false;
! 	if (pgntform->relpages != (int32) num_pages)
! 	{
! 		pgntform->relpages = (int32) num_pages;
! 		dirty = true;
! 	}
! 	if (pgntform->reltuples != (float4) num_tuples)
! 	{
! 		pgntform->reltuples = (float4) num_tuples;
! 		dirty = true;
! 	}
  
! 	/* If anything changed, write out the tuple */
! 	if (dirty)
! 		update_ntclass_entry(rd, ctup);
! 	heap_freetuple(ctup);
  
! 	heap_close(rd, RowExclusiveLock);
  
! 	/* Now go for the pg_class tuple */
! 	rd = heap_open(RelationRelationId, RowExclusiveLock);
  
! 	/* Fetch a copy of the tuple to scribble on */
! 	ctup = SearchSysCacheCopy(RELOID,
! 							  ObjectIdGetDatum(RelationGetRelid(rel)),
! 							  0, 0, 0);
! 	if (!HeapTupleIsValid(ctup))
! 		elog(ERROR, "pg_class entry for relid %u vanished during vacuuming",
! 			 RelationGetRelid(rel));
! 	pgcform = (Form_pg_class) GETSTRUCT(ctup);
  
! 	/* Apply required updates, if any, to copied tuple */
  
! 	dirty = false;
! 	if (pgcform->relhasindex != hasindex)
! 	{
! 		pgcform->relhasindex = hasindex;
! 		dirty = true;
  	}
! 	/*
! 	 * If we have discovered that there are no indexes, then there's no
! 	 * primary key either.	This could be done more thoroughly...
! 	 */
! 	if (!hasindex)
  	{
! 		if (pgcform->relhaspkey)
! 		{
! 			pgcform->relhaspkey = false;
! 			dirty = true;
! 		}
  	}
  
! 	/*
! 	 * If anything changed, write out the tuple
! 	 */
! 	if (dirty)
! 		heap_inplace_update(rd, ctup);
! 
! 	heap_close(rd, RowExclusiveLock);
  }
  
- 
  /*
!  *	vac_update_dbstats() -- update statistics for one database
   *
!  *		Update the whole-database statistics that are kept in its pg_database
!  *		row, and the flat-file copy of pg_database.
   *
   *		We violate transaction semantics here by overwriting the database's
!  *		existing pg_database tuple with the new values.  This is reasonably
!  *		safe since the new values are correct whether or not this transaction
   *		commits.  As with vac_update_relstats, this avoids leaving dead tuples
   *		behind after a VACUUM.
   *
!  *		This routine is shared by full and lazy VACUUM.  Note that it is only
!  *		applied after a database-wide VACUUM operation.
   */
  static void
! vac_update_dbstats(Oid dbid,
! 				   TransactionId vacuumXID,
! 				   TransactionId frozenXID)
  {
- 	Relation	relation;
  	HeapTuple	tuple;
  	Form_pg_database dbform;
  
! 	relation = heap_open(DatabaseRelationId, RowExclusiveLock);
  
! 	/* Fetch a copy of the tuple to scribble on */
! 	tuple = SearchSysCacheCopy(DATABASEOID,
! 							   ObjectIdGetDatum(dbid),
! 							   0, 0, 0);
! 	if (!HeapTupleIsValid(tuple))
! 		elog(ERROR, "could not find tuple for database %u", dbid);
! 	dbform = (Form_pg_database) GETSTRUCT(tuple);
! 
! 	/* overwrite the existing statistics in the tuple */
! 	dbform->datvacuumxid = vacuumXID;
! 	dbform->datfrozenxid = frozenXID;
  
! 	heap_inplace_update(relation, tuple);
  
! 	heap_close(relation, RowExclusiveLock);
  
! 	/* Mark the flat-file copy of pg_database for update at commit */
! 	database_file_update_needed();
! }
  
  
  /*
   *	vac_truncate_clog() -- attempt to truncate the commit log
--- 684,944 ----
  	Form_pg_class pgcform;
  	bool		dirty;
  
! 	PG_TRY();
! 	{
! 		/* Don't unfreeze pg_ntclass nor pg_class by doing this */
! 		disable_heap_unfreeze = true;
  
! 		/* Process pg_ntclass first */
! 		rd = heap_open(NtClassRelationId, RowExclusiveLock);
  
! 		/* Fetch a copy of the pg_ntclass tuple to scribble on */
! 		ctup = get_ntclass_entry(rd, rel);
  
! 		pgntform = (Form_pg_ntclass) GETSTRUCT(ctup);
  
! 		/* Apply required updates, if any, to copied tuple */
  
! 		dirty = false;
! 		if (pgntform->relpages != (int32) num_pages)
! 		{
! 			pgntform->relpages = (int32) num_pages;
! 			dirty = true;
! 		}
! 		if (pgntform->reltuples != (float4) num_tuples)
! 		{
! 			pgntform->reltuples = (float4) num_tuples;
! 			dirty = true;
! 		}
! 		if (pgntform->relminxid != minxid)
! 		{
! 			pgntform->relminxid = minxid;
! 			dirty = true;
! 		}
! 		/*
! 		 * If relminxid is Frozen (i.e., the table is truly frozen), it's more
! 		 * useful to mark it as having vacuumxid frozen as well.  This means
! 		 * tht this table does not impose any particular limit to pg_clog
! 		 * truncation.
! 		 *
! 		 * It seems a bit of a hack to be doing this here, but it would be even
! 		 * uglier to have all the callers do it.
! 		 */
! 		if (TransactionIdEquals(minxid, FrozenTransactionId))
! 			vacuumxid = FrozenTransactionId;
! 		if (pgntform->relvacuumxid != vacuumxid)
! 		{
! 			pgntform->relvacuumxid = vacuumxid;
! 			dirty = true;
! 		}
  
! 		/* If anything changed, write out the tuple */
! 		if (dirty)
! 			update_ntclass_entry(rd, ctup);
! 		heap_freetuple(ctup);
! 
! 		heap_close(rd, RowExclusiveLock);
! 
! 		/* Now go for the pg_class tuple */
! 		rd = heap_open(RelationRelationId, RowExclusiveLock);
! 
! 		/* Fetch a copy of the tuple to scribble on */
! 		ctup = SearchSysCacheCopy(RELOID,
! 								  ObjectIdGetDatum(RelationGetRelid(rel)),
! 								  0, 0, 0);
! 		if (!HeapTupleIsValid(ctup))
! 			elog(ERROR, "pg_class entry for relid %u vanished during vacuuming",
! 				 RelationGetRelid(rel));
! 		pgcform = (Form_pg_class) GETSTRUCT(ctup);
  
! 		/* Apply required updates, if any, to copied tuple */
  
! 		dirty = false;
! 		if (pgcform->relhasindex != hasindex)
! 		{
! 			pgcform->relhasindex = hasindex;
! 			dirty = true;
! 		}
! 		/*
! 		 * If we have discovered that there are no indexes, then there's no
! 		 * primary key either.	This could be done more thoroughly...
! 		 */
! 		if (!hasindex)
! 		{
! 			if (pgcform->relhaspkey)
! 			{
! 				pgcform->relhaspkey = false;
! 				dirty = true;
! 			}
! 		}
  
! 		/*
! 		 * If anything changed, write out the tuple
! 		 */
! 		if (dirty)
! 			heap_inplace_update(rd, ctup);
  
! 		heap_close(rd, RowExclusiveLock);
! 		heap_freetuple(ctup);
  	}
! 	PG_CATCH();
  	{
! 		disable_heap_unfreeze = false;
! 		PG_RE_THROW();
  	}
+ 	PG_END_TRY();
  
! 	disable_heap_unfreeze = false;
  }
  
  /*
!  *	vac_update_dbminxid() -- update the minimum Xid present in one database
   *
!  * 		Update pg_database's datminxid and datvacuumxid, and the flat-file copy
!  * 		of it.  datminxid is updated to the minimum of all relminxid found in
!  * 		pg_ntclass.
   *
   *		We violate transaction semantics here by overwriting the database's
!  *		existing pg_database tuple with the new value.  This is reasonably
!  *		safe since the new value is correct whether or not this transaction
   *		commits.  As with vac_update_relstats, this avoids leaving dead tuples
   *		behind after a VACUUM.
   *
!  *		This routine is shared by full and lazy VACUUM.
   */
  static void
! vac_update_dbminxid(Oid dbid)
  {
  	HeapTuple	tuple;
  	Form_pg_database dbform;
+ 	Relation	relation;
+ 	SysScanDesc	scan;
+ 	HeapTuple	ntclassTup;
+ 	TransactionId	newMinXid = InvalidTransactionId;
+ 	TransactionId	newVacXid = InvalidTransactionId;
+ 	bool		dirty = false;
  
! 	PG_TRY();
! 	{
! 		/*
! 		 * Disable heap unfreezing of pg_database, since we are going
! 		 * to update the tuple in-place and won't be writing our Xid on it.
! 		 */
! 		disable_heap_unfreeze = true;
  
! 		/* We must seqscan pg_ntclass to find the minimum Xid */
! 		relation = heap_open(NtClassRelationId, AccessShareLock);
  
! 		scan = systable_beginscan(relation, InvalidOid, false,
! 								  SnapshotNow, 0, NULL);
  
! 		while ((ntclassTup = systable_getnext(scan)) != NULL)
! 		{
! 			Form_pg_ntclass ntclassForm;
  
! 			ntclassForm = (Form_pg_ntclass) GETSTRUCT(ntclassTup);
! 
! 			/*
! 			 * Compute the minimum relminxid in all the tables in the database.
! 			 * We consider only normal Xids --- this means in particular we
! 			 * avoid setting the minimum to FrozenTransactionId here.  If all
! 			 * tables turn out to be frozen, we will exit the loop with the
! 			 * value set to InvalidTransactionId.  We cannot allow newMinXid to
! 			 * be set to FrozenTransactionId --- that messes us up because of
! 			 * the semantics of TransactionIdPrecedes.
! 			 *
! 			 * Other values we are ignoring here are InvalidTransactionId
! 			 * (which is set for some bootstrap tables) and
! 			 * BootstrapTransactionId.  This doesn't cause any problems because
! 			 * for all practical purposes they behave exactly like
! 			 * FrozenTransactionId.
! 			 */
! 			if (TransactionIdIsValid(ntclassForm->relminxid) &&
! 				TransactionIdIsNormal(ntclassForm->relminxid) &&
! 				(!TransactionIdIsValid(newMinXid) ||
! 				 TransactionIdPrecedes(ntclassForm->relminxid, newMinXid)))
! 				newMinXid = ntclassForm->relminxid;
! 
! 			/* ditto, for relvacuumxid */
! 			if (TransactionIdIsValid(ntclassForm->relvacuumxid) &&
! 				TransactionIdIsNormal(ntclassForm->relvacuumxid) &&
! 				(!TransactionIdIsValid(newVacXid) ||
! 				 TransactionIdPrecedes(ntclassForm->relvacuumxid, newVacXid)))
! 				newVacXid = ntclassForm->relvacuumxid;
! 		}
! 
! 		/* we're done with pg_ntclass */
! 		systable_endscan(scan);
! 		heap_close(relation, AccessShareLock);
  
+ 		/*
+ 		 * If we got InvalidTransactionId, then all tables must be frozen.  As
+ 		 * a special protection, we only allow a database to be wholly marked
+ 		 * as "frozen" if this is a standalone backend.  Otherwise, some other
+ 		 * backend may be modifying a table behind our back; we can't safely
+ 		 * assume that the database is truly frozen.  So if we detect that all
+ 		 * tables are frozen but we're running on a regular backend, fall back
+ 		 * to storing RecentXmin in datminxid (the minimum Xid which could be
+ 		 * unfreezing a table simultaneously.)
+ 		 */
+ 		if (!TransactionIdIsValid(newMinXid))
+ 			newMinXid = IsPostmasterEnvironment ? RecentXmin :
+ 				FrozenTransactionId;
+ 
+ 		/*
+ 		 * In datvacuumxid, if we got InvalidTransactionId we use
+ 		 * FrozenTransactionId in pg_database.  This case is not valid as
+ 		 * truncation point for pg_clog, but it's handled specially in
+ 		 * vac_truncate_clog() because it's useful as a permanent sign
+ 		 * that this database doesn't have a true lower limit on truncation.
+ 		 */
+ 		if (!TransactionIdIsValid(newVacXid))
+ 			newVacXid = FrozenTransactionId;
+ 
+ 		/* Now fetch the pg_database tuple we need to update. */
+ 		relation = heap_open(DatabaseRelationId, RowExclusiveLock);
+ 
+ 		/* Fetch a copy of the tuple to scribble on */
+ 		tuple = SearchSysCacheCopy(DATABASEOID,
+ 								   ObjectIdGetDatum(dbid),
+ 								   0, 0, 0);
+ 
+ 		if (!HeapTupleIsValid(tuple))
+ 			elog(ERROR, "could not find tuple for database %u", dbid);
+ 
+ 		dbform = (Form_pg_database) GETSTRUCT(tuple);
+ 
+ 		if (TransactionIdPrecedes(dbform->datminxid, newMinXid) ||
+ 			TransactionIdEquals(newMinXid, FrozenTransactionId))
+ 		{
+ 			dbform->datminxid = newMinXid;
+ 			dirty = true;
+ 		}
+ 		if (TransactionIdPrecedes(dbform->datvacuumxid, newVacXid) ||
+ 			TransactionIdEquals(newVacXid, FrozenTransactionId))
+ 		{
+ 			dbform->datvacuumxid = newVacXid;
+ 			dirty = true;
+ 		}
+ 
+ 		if (dirty)
+ 			heap_inplace_update(relation, tuple);
+ 
+ 		heap_freetuple(tuple);
+ 
+ 		heap_close(relation, RowExclusiveLock);
+ 	}
+ 	PG_CATCH();
+ 	{
+ 		/* Make sure to reenable heap unfreezing in case of error */
+ 		disable_heap_unfreeze = false;
+ 		PG_RE_THROW();
+ 	}
+ 	PG_END_TRY();
+ 
+ 	/* reenable heap unfreezing */
+ 	disable_heap_unfreeze = false;
+ }
  
  /*
   *	vac_truncate_clog() -- attempt to truncate the commit log
***************
*** 841,868 ****
   *		will generate more-annoying warnings, and ultimately refuse to issue
   *		any more new XIDs.
   *
-  *		The passed XIDs are simply the ones I just wrote into my pg_database
-  *		entry.	They're used to initialize the "min" calculations.
-  *
   *		This routine is shared by full and lazy VACUUM.  Note that it is only
   *		applied after a database-wide VACUUM operation.
   */
  static void
! vac_truncate_clog(TransactionId vacuumXID, TransactionId frozenXID)
  {
  	TransactionId myXID = GetCurrentTransactionId();
  	Relation	relation;
  	HeapScanDesc scan;
  	HeapTuple	tuple;
  	int32		age;
  	NameData	oldest_datname;
  	bool		vacuumAlreadyWrapped = false;
! 	bool		frozenAlreadyWrapped = false;
  
! 	/* init oldest_datname to sync with my frozenXID */
  	namestrcpy(&oldest_datname, get_database_name(MyDatabaseId));
  
  	/*
  	 * Note: the "already wrapped" cases should now be impossible due to the
  	 * defenses in GetNewTransactionId, but we keep them anyway.
  	 */
--- 953,988 ----
   *		will generate more-annoying warnings, and ultimately refuse to issue
   *		any more new XIDs.
   *
   *		This routine is shared by full and lazy VACUUM.  Note that it is only
   *		applied after a database-wide VACUUM operation.
   */
  static void
! vac_truncate_clog(void)
  {
  	TransactionId myXID = GetCurrentTransactionId();
+ 	TransactionId minXID;
+ 	TransactionId vacuumXID;
  	Relation	relation;
  	HeapScanDesc scan;
  	HeapTuple	tuple;
  	int32		age;
  	NameData	oldest_datname;
  	bool		vacuumAlreadyWrapped = false;
! 	bool		minAlreadyWrapped = false;
  
! 	/*
! 	 * Initialize the minimum values to a recent value.
! 	 */
! 	minXID = vacuumXID = RecentXmin;
  	namestrcpy(&oldest_datname, get_database_name(MyDatabaseId));
  
  	/*
+ 	 * Note we don't initialize the oldest database name here.  This is because
+ 	 * the name will only be used if myXID - minXID is some positive quantity,
+ 	 * and if that happens, we will also initialize the name in the loop below.
+ 	 */
+ 
+ 	/*
  	 * Note: the "already wrapped" cases should now be impossible due to the
  	 * defenses in GetNewTransactionId, but we keep them anyway.
  	 */
***************
*** 874,884 ****
  	{
  		Form_pg_database dbform = (Form_pg_database) GETSTRUCT(tuple);
  
! 		/* Ignore non-connectable databases (eg, template0) */
! 		/* It's assumed that these have been frozen correctly */
! 		if (!dbform->datallowconn)
! 			continue;
! 
  		if (TransactionIdIsNormal(dbform->datvacuumxid))
  		{
  			if (TransactionIdPrecedes(myXID, dbform->datvacuumxid))
--- 994,1009 ----
  	{
  		Form_pg_database dbform = (Form_pg_database) GETSTRUCT(tuple);
  
! 		/*
! 		 * Note we ignore FrozenTransactionId here for both values.  If all
! 		 * databases turn out to be frozen, the values will end up as the
! 		 * current XID, which is the correct truncation point for pg_clog and
! 		 * also the correct value for the varsup.c limit.
! 		 *
! 		 * Also note that the all-databases-are-frozen case is pretty rare.
! 		 * It can only happen if the user VACUUM FREEZEs all databases using
! 		 * standalone backends.
! 		 */
  		if (TransactionIdIsNormal(dbform->datvacuumxid))
  		{
  			if (TransactionIdPrecedes(myXID, dbform->datvacuumxid))
***************
*** 886,898 ****
  			else if (TransactionIdPrecedes(dbform->datvacuumxid, vacuumXID))
  				vacuumXID = dbform->datvacuumxid;
  		}
! 		if (TransactionIdIsNormal(dbform->datfrozenxid))
  		{
! 			if (TransactionIdPrecedes(myXID, dbform->datfrozenxid))
! 				frozenAlreadyWrapped = true;
! 			else if (TransactionIdPrecedes(dbform->datfrozenxid, frozenXID))
  			{
! 				frozenXID = dbform->datfrozenxid;
  				namecpy(&oldest_datname, &dbform->datname);
  			}
  		}
--- 1011,1023 ----
  			else if (TransactionIdPrecedes(dbform->datvacuumxid, vacuumXID))
  				vacuumXID = dbform->datvacuumxid;
  		}
! 		if (TransactionIdIsNormal(dbform->datminxid))
  		{
! 			if (TransactionIdPrecedes(myXID, dbform->datminxid))
! 				minAlreadyWrapped = true;
! 			else if (TransactionIdPrecedes(dbform->datminxid, minXID))
  			{
! 				minXID = dbform->datminxid;
  				namecpy(&oldest_datname, &dbform->datname);
  			}
  		}
***************
*** 921,927 ****
  	 * Do not update varsup.c if we seem to have suffered wraparound already;
  	 * the computed XID might be bogus.
  	 */
! 	if (frozenAlreadyWrapped)
  	{
  		ereport(WARNING,
  				(errmsg("some databases have not been vacuumed in over 1 billion transactions"),
--- 1046,1052 ----
  	 * Do not update varsup.c if we seem to have suffered wraparound already;
  	 * the computed XID might be bogus.
  	 */
! 	if (minAlreadyWrapped)
  	{
  		ereport(WARNING,
  				(errmsg("some databases have not been vacuumed in over 1 billion transactions"),
***************
*** 930,939 ****
  	}
  
  	/* Update the wrap limit for GetNewTransactionId */
! 	SetTransactionIdLimit(frozenXID, &oldest_datname);
  
  	/* Give warning about impending wraparound problems */
! 	age = (int32) (myXID - frozenXID);
  	if (age > (int32) ((MaxTransactionId >> 3) * 3))
  		ereport(WARNING,
  		   (errmsg("database \"%s\" must be vacuumed within %u transactions",
--- 1055,1064 ----
  	}
  
  	/* Update the wrap limit for GetNewTransactionId */
! 	SetTransactionIdLimit(minXID, &oldest_datname);
  
  	/* Give warning about impending wraparound problems */
! 	age = (int32) (myXID - minXID);
  	if (age > (int32) ((MaxTransactionId >> 3) * 3))
  		ereport(WARNING,
  		   (errmsg("database \"%s\" must be vacuumed within %u transactions",
***************
*** 955,965 ****
  /*
   *	vacuum_rel() -- vacuum one heap relation
   *
-  *		Returns TRUE if we actually processed the relation (or can ignore it
-  *		for some reason), FALSE if we failed to process it due to permissions
-  *		or other reasons.  (A FALSE result really means that some data
-  *		may have been left unvacuumed, so we can't update XID stats.)
-  *
   *		Doing one heap at a time incurs extra overhead, since we need to
   *		check that the heap exists again just before we vacuum it.	The
   *		reason that we do this is so that vacuuming can be spread across
--- 1080,1085 ----
***************
*** 968,981 ****
   *
   *		At entry and exit, we are not inside a transaction.
   */
! static bool
  vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool allow_toast)
  {
  	LOCKMODE	lmode;
  	Relation	onerel;
  	LockRelId	onerelid;
  	Oid			toast_relid;
- 	bool		result;
  
  	/* Begin a transaction for vacuuming this relation */
  	StartTransactionCommand();
--- 1088,1100 ----
   *
   *		At entry and exit, we are not inside a transaction.
   */
! static void
  vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool allow_toast)
  {
  	LOCKMODE	lmode;
  	Relation	onerel;
  	LockRelId	onerelid;
  	Oid			toast_relid;
  
  	/* Begin a transaction for vacuuming this relation */
  	StartTransactionCommand();
***************
*** 1004,1021 ****
  	{
  		StrategyHintVacuum(false);
  		CommitTransactionCommand();
! 		return true;			/* okay 'cause no data there */
  	}
  
  	/*
  	 * Determine the type of lock we want --- hard exclusive lock for a FULL
! 	 * vacuum, but just ShareUpdateExclusiveLock for concurrent vacuum. Either
! 	 * way, we can be sure that no other backend is vacuuming the same table.
  	 */
! 	lmode = vacstmt->full ? AccessExclusiveLock : ShareUpdateExclusiveLock;
  
  	/*
! 	 * Open the class, get an appropriate lock on it, and check permissions.
  	 *
  	 * We allow the user to vacuum a table if he is superuser, the table
  	 * owner, or the database owner (but in the latter case, only if it's not
--- 1123,1164 ----
  	{
  		StrategyHintVacuum(false);
  		CommitTransactionCommand();
! 		return;
  	}
  
  	/*
  	 * Determine the type of lock we want --- hard exclusive lock for a FULL
! 	 * vacuum, ExclusiveLock for VACUUM FREEZE, but just
! 	 * ShareUpdateExclusiveLock for concurrent vacuum. Either way, we can be
! 	 * sure that no other backend is vacuuming the same table.
! 	 */
! 	lmode = vacstmt->full ? AccessExclusiveLock :
! 		vacstmt->freeze ? ExclusiveLock : ShareUpdateExclusiveLock;
! 
! 	/*
! 	 * Open the class and get an appropriate lock on it.
  	 */
! 	PG_TRY();
! 	{
! 		/*
! 		 * Note that we can skip unfreezing the table at this moment, because
! 		 * we will update the correct relminxid later, if needed.  Furthermore,
! 		 * doing this allows us to skip vacuuming the table at all if it has
! 		 * been frozen and not modified since.
! 		 */
! 		disable_heap_unfreeze = true;
! 		onerel = relation_open(relid, lmode);
! 	}
! 	PG_CATCH();
! 	{
! 		disable_heap_unfreeze = false;
! 		PG_RE_THROW();
! 	}
! 	PG_END_TRY();
! 	disable_heap_unfreeze = false;
  
  	/*
! 	 * Check permissions on the table.
  	 *
  	 * We allow the user to vacuum a table if he is superuser, the table
  	 * owner, or the database owner (but in the latter case, only if it's not
***************
*** 1024,1031 ****
  	 * Note we choose to treat permissions failure as a WARNING and keep
  	 * trying to vacuum the rest of the DB --- is this appropriate?
  	 */
- 	onerel = relation_open(relid, lmode);
- 
  	if (!(pg_class_ownercheck(RelationGetRelid(onerel), GetUserId()) ||
  		  (pg_database_ownercheck(MyDatabaseId, GetUserId()) && !onerel->rd_rel->relisshared)))
  	{
--- 1167,1172 ----
***************
*** 1035,1041 ****
  		relation_close(onerel, lmode);
  		StrategyHintVacuum(false);
  		CommitTransactionCommand();
! 		return false;
  	}
  
  	/*
--- 1176,1182 ----
  		relation_close(onerel, lmode);
  		StrategyHintVacuum(false);
  		CommitTransactionCommand();
! 		return;
  	}
  
  	/*
***************
*** 1053,1059 ****
  		relation_close(onerel, lmode);
  		StrategyHintVacuum(false);
  		CommitTransactionCommand();
! 		return false;
  	}
  
  	/*
--- 1194,1200 ----
  		relation_close(onerel, lmode);
  		StrategyHintVacuum(false);
  		CommitTransactionCommand();
! 		return;
  	}
  
  	/*
***************
*** 1069,1075 ****
  		relation_close(onerel, lmode);
  		StrategyHintVacuum(false);
  		CommitTransactionCommand();
! 		return false;
  	}
  
  	/*
--- 1210,1216 ----
  		relation_close(onerel, lmode);
  		StrategyHintVacuum(false);
  		CommitTransactionCommand();
! 		return;
  	}
  
  	/*
***************
*** 1084,1090 ****
  		relation_close(onerel, lmode);
  		StrategyHintVacuum(false);
  		CommitTransactionCommand();
! 		return true;			/* assume no long-lived data in temp tables */
  	}
  
  	/*
--- 1225,1231 ----
  		relation_close(onerel, lmode);
  		StrategyHintVacuum(false);
  		CommitTransactionCommand();
! 		return;			/* assume no long-lived data in temp tables */
  	}
  
  	/*
***************
*** 1113,1120 ****
  	else
  		lazy_vacuum_rel(onerel, vacstmt);
  
- 	result = true;				/* did the vacuum */
- 
  	/* all done with this class, but hold lock until commit */
  	relation_close(onerel, NoLock);
  
--- 1254,1259 ----
***************
*** 1132,1148 ****
  	 * totally unimportant for toast relations.
  	 */
  	if (toast_relid != InvalidOid)
! 	{
! 		if (!vacuum_rel(toast_relid, vacstmt, true))
! 			result = false;		/* failed to vacuum the TOAST table? */
! 	}
  
  	/*
  	 * Now release the session-level lock on the master table.
  	 */
  	UnlockRelationForSession(&onerelid, lmode);
- 
- 	return result;
  }
  
  
--- 1271,1282 ----
  	 * totally unimportant for toast relations.
  	 */
  	if (toast_relid != InvalidOid)
! 		vacuum_rel(toast_relid, vacstmt, true);
  
  	/*
  	 * Now release the session-level lock on the master table.
  	 */
  	UnlockRelationForSession(&onerelid, lmode);
  }
  
  
***************
*** 1174,1179 ****
--- 1308,1315 ----
  	int			nindexes,
  				i;
  	VRelStats  *vacrelstats;
+ 	TransactionId FreezeLimit,
+ 				  OldestXmin;
  
  	vacuum_set_xid_limits(vacstmt, onerel->rd_rel->relisshared,
  						  &OldestXmin, &FreezeLimit);
***************
*** 1186,1194 ****
  	vacrelstats->rel_tuples = 0;
  	vacrelstats->hasindex = false;
  
  	/* scan the heap */
  	vacuum_pages.num_pages = fraged_pages.num_pages = 0;
! 	scan_heap(vacrelstats, onerel, &vacuum_pages, &fraged_pages);
  
  	/* Now open all indexes of the relation */
  	vac_open_indexes(onerel, AccessExclusiveLock, &nindexes, &Irel);
--- 1322,1342 ----
  	vacrelstats->rel_tuples = 0;
  	vacrelstats->hasindex = false;
  
+ 	/*
+ 	 * Set initial minimum Xid, which will be updated if a smaller Xid is found
+ 	 * in the relation by scan_heap.
+ 	 *
+ 	 * We use RecentXmin here (the minimum Xid that belongs to a transaction
+ 	 * that is still open according to our snapshot), because it is the
+ 	 * earliest transaction that could insert new tuples in the table after our
+ 	 * VACUUM is done.
+ 	 */
+ 	vacrelstats->minxid = RecentXmin;
+ 
  	/* scan the heap */
  	vacuum_pages.num_pages = fraged_pages.num_pages = 0;
! 	scan_heap(vacrelstats, onerel, &vacuum_pages, &fraged_pages, FreezeLimit,
! 			  OldestXmin);
  
  	/* Now open all indexes of the relation */
  	vac_open_indexes(onerel, AccessExclusiveLock, &nindexes, &Irel);
***************
*** 1216,1222 ****
  	{
  		/* Try to shrink heap */
  		repair_frag(vacrelstats, onerel, &vacuum_pages, &fraged_pages,
! 					nindexes, Irel);
  		vac_close_indexes(nindexes, Irel, NoLock);
  	}
  	else
--- 1364,1370 ----
  	{
  		/* Try to shrink heap */
  		repair_frag(vacrelstats, onerel, &vacuum_pages, &fraged_pages,
! 					nindexes, Irel, OldestXmin);
  		vac_close_indexes(nindexes, Irel, NoLock);
  	}
  	else
***************
*** 1234,1240 ****
  
  	/* update statistics in pg_class */
  	vac_update_relstats(onerel, vacrelstats->rel_pages,
! 						vacrelstats->rel_tuples, vacrelstats->hasindex);
  
  	/* report results to the stats collector, too */
  	pgstat_report_vacuum(RelationGetRelid(onerel), onerel->rd_rel->relisshared,
--- 1382,1389 ----
  
  	/* update statistics in pg_class */
  	vac_update_relstats(onerel, vacrelstats->rel_pages,
! 						vacrelstats->rel_tuples, vacrelstats->hasindex,
! 						vacrelstats->minxid, OldestXmin);
  
  	/* report results to the stats collector, too */
  	pgstat_report_vacuum(RelationGetRelid(onerel), onerel->rd_rel->relisshared,
***************
*** 1248,1263 ****
   *		This routine sets commit status bits, constructs vacuum_pages (list
   *		of pages we need to compact free space on and/or clean indexes of
   *		deleted tuples), constructs fraged_pages (list of pages with free
!  *		space that tuples could be moved into), and calculates statistics
!  *		on the number of live tuples in the heap.
   */
  static void
  scan_heap(VRelStats *vacrelstats, Relation onerel,
! 		  VacPageList vacuum_pages, VacPageList fraged_pages)
  {
  	BlockNumber nblocks,
  				blkno;
- 	HeapTupleData tuple;
  	char	   *relname;
  	VacPage		vacpage;
  	BlockNumber empty_pages,
--- 1397,1413 ----
   *		This routine sets commit status bits, constructs vacuum_pages (list
   *		of pages we need to compact free space on and/or clean indexes of
   *		deleted tuples), constructs fraged_pages (list of pages with free
!  *		space that tuples could be moved into), calculates statistics on the
!  *		number of live tuples in the heap, and figures out the minimum normal
!  *		Xid present anywhere on the table.
   */
  static void
  scan_heap(VRelStats *vacrelstats, Relation onerel,
! 		  VacPageList vacuum_pages, VacPageList fraged_pages,
! 		  TransactionId FreezeLimit, TransactionId OldestXmin)
  {
  	BlockNumber nblocks,
  				blkno;
  	char	   *relname;
  	VacPage		vacpage;
  	BlockNumber empty_pages,
***************
*** 1371,1376 ****
--- 1521,1527 ----
  		{
  			ItemId		itemid = PageGetItemId(page, offnum);
  			bool		tupgone = false;
+ 			HeapTupleData tuple;
  
  			/*
  			 * Collect un-used items too - it's possible to have indexes
***************
*** 1512,1517 ****
--- 1663,1691 ----
  					min_tlen = tuple.t_len;
  				if (tuple.t_len > max_tlen)
  					max_tlen = tuple.t_len;
+ 
+ 				/*
+ 				 * Checks for pg_class.relminxid: determine the earliest
+ 				 * Xid in any tuple of any table.
+ 				 */
+ 				if (TransactionIdIsNormal(HeapTupleHeaderGetXmin(tuple.t_data)) &&
+ 					TransactionIdPrecedes(HeapTupleHeaderGetXmin(tuple.t_data),
+ 										  vacrelstats->minxid))
+ 					vacrelstats->minxid = HeapTupleHeaderGetXmin(tuple.t_data);
+ 
+ 				/*
+ 				 * If XMAX is not marked INVALID, we assume it's valid without
+ 				 * making any check on it --- it must be recently obsoleted or
+ 				 * still running, else HeapTupleSatisfiesVacuum would have
+ 				 * deemed it removable.
+ 				 */
+ 				if (!(tuple.t_data->t_infomask | HEAP_XMAX_INVALID))
+ 				{
+ 					if (TransactionIdIsNormal(HeapTupleHeaderGetXmax(tuple.t_data)) &&
+ 						TransactionIdPrecedes(HeapTupleHeaderGetXmax(tuple.t_data),
+ 											  vacrelstats->minxid))
+ 						vacrelstats->minxid = HeapTupleHeaderGetXmax(tuple.t_data);
+ 				}
  			}
  		}						/* scan along page */
  
***************
*** 1651,1657 ****
  static void
  repair_frag(VRelStats *vacrelstats, Relation onerel,
  			VacPageList vacuum_pages, VacPageList fraged_pages,
! 			int nindexes, Relation *Irel)
  {
  	TransactionId myXID = GetCurrentTransactionId();
  	Buffer		dst_buffer = InvalidBuffer;
--- 1825,1831 ----
  static void
  repair_frag(VRelStats *vacrelstats, Relation onerel,
  			VacPageList vacuum_pages, VacPageList fraged_pages,
! 			int nindexes, Relation *Irel, TransactionId OldestXmin)
  {
  	TransactionId myXID = GetCurrentTransactionId();
  	Buffer		dst_buffer = InvalidBuffer;
***************
*** 2994,3000 ****
  	/* now update statistics in pg_class */
  	vac_update_relstats(indrel,
  						stats->num_pages, stats->num_index_tuples,
! 						false);
  
  	ereport(elevel,
  			(errmsg("index \"%s\" now contains %.0f row versions in %u pages",
--- 3168,3174 ----
  	/* now update statistics in pg_class */
  	vac_update_relstats(indrel,
  						stats->num_pages, stats->num_index_tuples,
! 						false, InvalidTransactionId, InvalidTransactionId);
  
  	ereport(elevel,
  			(errmsg("index \"%s\" now contains %.0f row versions in %u pages",
***************
*** 3063,3069 ****
  	/* now update statistics in pg_class */
  	vac_update_relstats(indrel,
  						stats->num_pages, stats->num_index_tuples,
! 						false);
  
  	ereport(elevel,
  			(errmsg("index \"%s\" now contains %.0f row versions in %u pages",
--- 3237,3243 ----
  	/* now update statistics in pg_class */
  	vac_update_relstats(indrel,
  						stats->num_pages, stats->num_index_tuples,
! 						false, InvalidTransactionId, InvalidTransactionId);
  
  	ereport(elevel,
  			(errmsg("index \"%s\" now contains %.0f row versions in %u pages",
diff -rc -X diff-ignore 11fixclass/src/backend/commands/vacuumlazy.c 12ntrelminxid/src/backend/commands/vacuumlazy.c
*** 11fixclass/src/backend/commands/vacuumlazy.c	2006-06-10 19:17:47.000000000 -0400
--- 12ntrelminxid/src/backend/commands/vacuumlazy.c	2006-06-11 02:41:44.000000000 -0400
***************
*** 42,47 ****
--- 42,50 ----
  #include "access/genam.h"
  #include "access/heapam.h"
  #include "access/xlog.h"
+ #include "catalog/catalog.h"
+ #include "catalog/heap.h"
+ #include "catalog/pg_ntclass.h"
  #include "commands/vacuum.h"
  #include "miscadmin.h"
  #include "pgstat.h"
***************
*** 72,77 ****
--- 75,81 ----
  	double		tuples_deleted;
  	BlockNumber nonempty_pages; /* actually, last nonempty page + 1 */
  	Size		threshold;		/* minimum interesting free space */
+ 	TransactionId minxid;		/* minimum Xid present anywhere in table */
  	/* List of TIDs of tuples we intend to delete */
  	/* NB: this list is ordered by TID address */
  	int			num_dead_tuples;	/* current # of entries */
***************
*** 88,100 ****
  
  static int	elevel = -1;
  
- static TransactionId OldestXmin;
- static TransactionId FreezeLimit;
- 
  
  /* non-export function prototypes */
  static void lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
! 			   Relation *Irel, int nindexes);
  static void lazy_vacuum_heap(Relation onerel, LVRelStats *vacrelstats);
  static void lazy_vacuum_index(Relation indrel,
  							  IndexBulkDeleteResult **stats,
--- 92,102 ----
  
  static int	elevel = -1;
  
  
  /* non-export function prototypes */
  static void lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
! 			   Relation *Irel, int nindexes, TransactionId FreezeLimit,
! 			   TransactionId OldestXmin);
  static void lazy_vacuum_heap(Relation onerel, LVRelStats *vacrelstats);
  static void lazy_vacuum_index(Relation indrel,
  							  IndexBulkDeleteResult **stats,
***************
*** 104,112 ****
  							   LVRelStats *vacrelstats);
  static int lazy_vacuum_page(Relation onerel, BlockNumber blkno, Buffer buffer,
  				 int tupindex, LVRelStats *vacrelstats);
! static void lazy_truncate_heap(Relation onerel, LVRelStats *vacrelstats);
  static BlockNumber count_nondeletable_pages(Relation onerel,
! 						 LVRelStats *vacrelstats);
  static void lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks);
  static void lazy_record_dead_tuple(LVRelStats *vacrelstats,
  					   ItemPointer itemptr);
--- 106,115 ----
  							   LVRelStats *vacrelstats);
  static int lazy_vacuum_page(Relation onerel, BlockNumber blkno, Buffer buffer,
  				 int tupindex, LVRelStats *vacrelstats);
! static void lazy_truncate_heap(Relation onerel, LVRelStats *vacrelstats,
! 							   TransactionId OldestXmin);
  static BlockNumber count_nondeletable_pages(Relation onerel,
! 						 LVRelStats *vacrelstats, TransactionId OldestXmin);
  static void lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks);
  static void lazy_record_dead_tuple(LVRelStats *vacrelstats,
  					   ItemPointer itemptr);
***************
*** 122,128 ****
   *	lazy_vacuum_rel() -- perform LAZY VACUUM for one heap relation
   *
   *		This routine vacuums a single heap, cleans out its indexes, and
!  *		updates its num_pages and num_tuples statistics.
   *
   *		At entry, we have already established a transaction and opened
   *		and locked the relation.
--- 125,132 ----
   *	lazy_vacuum_rel() -- perform LAZY VACUUM for one heap relation
   *
   *		This routine vacuums a single heap, cleans out its indexes, and
!  *		updates its relpages and reltuples statistics, as well as the
!  *		relminxid and relvacuumxid information.
   *
   *		At entry, we have already established a transaction and opened
   *		and locked the relation.
***************
*** 135,146 ****
--- 139,177 ----
  	int			nindexes;
  	bool		hasindex;
  	BlockNumber possibly_freeable;
+ 	TransactionId OldestXmin,
+ 				  FreezeLimit;
  
  	if (vacstmt->verbose)
  		elevel = INFO;
  	else
  		elevel = DEBUG2;
  
+ 	/*
+ 	 * We can skip vacuuming a frozen table, since we know nobody has touched
+ 	 * it since the last VACUUM.
+ 	 */
+ 	{
+ 		HeapTuple	ctup;
+ 		Form_pg_ntclass ntForm;
+ 		Relation	ntRel;
+ 		bool		canskip = false;
+ 
+ 		ntRel = heap_open(NtClassRelationId, AccessShareLock);
+ 		ctup = get_ntclass_entry(ntRel, onerel);
+ 
+ 		ntForm = (Form_pg_ntclass) GETSTRUCT(ctup);
+ 
+ 		if (TransactionIdEquals(ntForm->relminxid, FrozenTransactionId))
+ 			canskip = true;
+ 
+ 		heap_freetuple(ctup);
+ 		heap_close(ntRel, AccessShareLock);
+ 
+ 		if (canskip)
+ 			return;
+ 	}
+ 
  	vacuum_set_xid_limits(vacstmt, onerel->rd_rel->relisshared,
  						  &OldestXmin, &FreezeLimit);
  
***************
*** 150,161 ****
  	/* XXX should we scale it up or down?  Adjust vacuum.c too, if so */
  	vacrelstats->threshold = GetAvgFSMRequestSize(&onerel->rd_node);
  
  	/* Open all indexes of the relation */
  	vac_open_indexes(onerel, ShareUpdateExclusiveLock, &nindexes, &Irel);
  	hasindex = (nindexes > 0);
  
  	/* Do the vacuuming */
! 	lazy_scan_heap(onerel, vacrelstats, Irel, nindexes);
  
  	/* Done with indexes */
  	vac_close_indexes(nindexes, Irel, NoLock);
--- 181,214 ----
  	/* XXX should we scale it up or down?  Adjust vacuum.c too, if so */
  	vacrelstats->threshold = GetAvgFSMRequestSize(&onerel->rd_node);
  
+ 	/*
+ 	 * Set initial minimum Xid, which will be updated if a smaller Xid is found
+ 	 * in the relation by lazy_scan_heap.
+ 	 *
+ 	 * In VACUUM FREEZE, we use FrozenTransactionId here.  This is safe
+ 	 * because we acquired ExclusiveLock above, so no one can be inserting 
+ 	 * newer tuples in pages earlier to those we have scanned.  If there's any
+ 	 * tuple whose Xid we can't change, the lower bound will be raised.
+ 	 *
+ 	 * In the non-FREEZE case, we use RecentXmin here (the minimum Xid that
+ 	 * belongs to a transaction that is still open according to our snapshot),
+ 	 * because it is the earliest transaction that could concurrently insert
+ 	 * new tuples in the table.
+ 	 *
+ 	 * The FREEZE case doesn't have an equivalent in VACUUM FULL because FULL
+ 	 * in combination with FREEZE is verboten.
+ 	 */
+ 	if (vacstmt->freeze)
+ 		vacrelstats->minxid = FrozenTransactionId;
+ 	else
+ 		vacrelstats->minxid = RecentXmin;
+ 
  	/* Open all indexes of the relation */
  	vac_open_indexes(onerel, ShareUpdateExclusiveLock, &nindexes, &Irel);
  	hasindex = (nindexes > 0);
  
  	/* Do the vacuuming */
! 	lazy_scan_heap(onerel, vacrelstats, Irel, nindexes, FreezeLimit, OldestXmin);
  
  	/* Done with indexes */
  	vac_close_indexes(nindexes, Irel, NoLock);
***************
*** 169,175 ****
  	possibly_freeable = vacrelstats->rel_pages - vacrelstats->nonempty_pages;
  	if (possibly_freeable >= REL_TRUNCATE_MINIMUM ||
  		possibly_freeable >= vacrelstats->rel_pages / REL_TRUNCATE_FRACTION)
! 		lazy_truncate_heap(onerel, vacrelstats);
  
  	/* Update shared free space map with final free space info */
  	lazy_update_fsm(onerel, vacrelstats);
--- 222,228 ----
  	possibly_freeable = vacrelstats->rel_pages - vacrelstats->nonempty_pages;
  	if (possibly_freeable >= REL_TRUNCATE_MINIMUM ||
  		possibly_freeable >= vacrelstats->rel_pages / REL_TRUNCATE_FRACTION)
! 		lazy_truncate_heap(onerel, vacrelstats, OldestXmin);
  
  	/* Update shared free space map with final free space info */
  	lazy_update_fsm(onerel, vacrelstats);
***************
*** 177,184 ****
  	/* Update statistics in pg_class */
  	vac_update_relstats(onerel,
  						vacrelstats->rel_pages,
! 						vacrelstats->rel_tuples,
! 						hasindex);
  
  	/* report results to the stats collector, too */
  	pgstat_report_vacuum(RelationGetRelid(onerel), onerel->rd_rel->relisshared,
--- 230,237 ----
  	/* Update statistics in pg_class */
  	vac_update_relstats(onerel,
  						vacrelstats->rel_pages,
! 						vacrelstats->rel_tuples, hasindex,
! 						vacrelstats->minxid, OldestXmin);
  
  	/* report results to the stats collector, too */
  	pgstat_report_vacuum(RelationGetRelid(onerel), onerel->rd_rel->relisshared,
***************
*** 193,202 ****
   *		and pages with free space, and calculates statistics on the number
   *		of live tuples in the heap.  When done, or when we run low on space
   *		for dead-tuple TIDs, invoke vacuuming of indexes and heap.
   */
  static void
  lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
! 			   Relation *Irel, int nindexes)
  {
  	BlockNumber nblocks,
  				blkno;
--- 246,259 ----
   *		and pages with free space, and calculates statistics on the number
   *		of live tuples in the heap.  When done, or when we run low on space
   *		for dead-tuple TIDs, invoke vacuuming of indexes and heap.
+  *
+  *		It also stores in vacrelstats.minxid the minimum Xid found anywhere on
+  *		the table, for later recording it in pg_ntclass.relminxid.
   */
  static void
  lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
! 			   Relation *Irel, int nindexes, TransactionId FreezeLimit,
! 			   TransactionId OldestXmin)
  {
  	BlockNumber nblocks,
  				blkno;
***************
*** 408,413 ****
--- 465,484 ----
  			{
  				num_tuples += 1;
  				hastup = true;
+ 
+ 				/* 
+ 				 * If the tuple is alive, we consider it for the "minxid"
+ 				 * calculations.
+ 				 */
+ 				if (TransactionIdIsNormal(HeapTupleHeaderGetXmin(tuple.t_data)) &&
+ 					TransactionIdPrecedes(HeapTupleHeaderGetXmin(tuple.t_data),
+ 										  vacrelstats->minxid))
+ 					vacrelstats->minxid = HeapTupleHeaderGetXmin(tuple.t_data);
+ 
+ 				if (TransactionIdIsNormal(HeapTupleHeaderGetXmax(tuple.t_data)) &&
+ 					TransactionIdPrecedes(HeapTupleHeaderGetXmax(tuple.t_data),
+ 										  vacrelstats->minxid))
+ 					vacrelstats->minxid = HeapTupleHeaderGetXmax(tuple.t_data);
  			}
  		}						/* scan along page */
  
***************
*** 668,676 ****
  
  	/* now update statistics in pg_class */
  	vac_update_relstats(indrel,
! 						stats->num_pages,
! 						stats->num_index_tuples,
! 						false);
  
  	ereport(elevel,
  			(errmsg("index \"%s\" now contains %.0f row versions in %u pages",
--- 739,746 ----
  
  	/* now update statistics in pg_class */
  	vac_update_relstats(indrel,
! 						stats->num_pages, stats->num_index_tuples,
! 						false, InvalidTransactionId, InvalidTransactionId);
  
  	ereport(elevel,
  			(errmsg("index \"%s\" now contains %.0f row versions in %u pages",
***************
*** 691,697 ****
   * lazy_truncate_heap - try to truncate off any empty pages at the end
   */
  static void
! lazy_truncate_heap(Relation onerel, LVRelStats *vacrelstats)
  {
  	BlockNumber old_rel_pages = vacrelstats->rel_pages;
  	BlockNumber new_rel_pages;
--- 761,768 ----
   * lazy_truncate_heap - try to truncate off any empty pages at the end
   */
  static void
! lazy_truncate_heap(Relation onerel, LVRelStats *vacrelstats,
! 				   TransactionId OldestXmin)
  {
  	BlockNumber old_rel_pages = vacrelstats->rel_pages;
  	BlockNumber new_rel_pages;
***************
*** 732,738 ****
  	 * because other backends could have added tuples to these pages whilst we
  	 * were vacuuming.
  	 */
! 	new_rel_pages = count_nondeletable_pages(onerel, vacrelstats);
  
  	if (new_rel_pages >= old_rel_pages)
  	{
--- 803,809 ----
  	 * because other backends could have added tuples to these pages whilst we
  	 * were vacuuming.
  	 */
! 	new_rel_pages = count_nondeletable_pages(onerel, vacrelstats, OldestXmin);
  
  	if (new_rel_pages >= old_rel_pages)
  	{
***************
*** 787,793 ****
   * Returns number of nondeletable pages (last nonempty page + 1).
   */
  static BlockNumber
! count_nondeletable_pages(Relation onerel, LVRelStats *vacrelstats)
  {
  	BlockNumber blkno;
  	HeapTupleData tuple;
--- 858,865 ----
   * Returns number of nondeletable pages (last nonempty page + 1).
   */
  static BlockNumber
! count_nondeletable_pages(Relation onerel, LVRelStats *vacrelstats,
! 						 TransactionId OldestXmin)
  {
  	BlockNumber blkno;
  	HeapTupleData tuple;
diff -rc -X diff-ignore 11fixclass/src/backend/libpq/hba.c 12ntrelminxid/src/backend/libpq/hba.c
*** 11fixclass/src/backend/libpq/hba.c	2006-03-08 16:23:25.000000000 -0300
--- 12ntrelminxid/src/backend/libpq/hba.c	2006-06-10 19:38:04.000000000 -0400
***************
*** 1005,1011 ****
   *	dbname: gets database name (must be of size NAMEDATALEN bytes)
   *	dboid: gets database OID
   *	dbtablespace: gets database's default tablespace's OID
!  *	dbfrozenxid: gets database's frozen XID
   *	dbvacuumxid: gets database's vacuum XID
   *
   * This is not much related to the other functions in hba.c, but we put it
--- 1005,1011 ----
   *	dbname: gets database name (must be of size NAMEDATALEN bytes)
   *	dboid: gets database OID
   *	dbtablespace: gets database's default tablespace's OID
!  *	dbminxid: gets database's minimum XID
   *	dbvacuumxid: gets database's vacuum XID
   *
   * This is not much related to the other functions in hba.c, but we put it
***************
*** 1013,1019 ****
   */
  bool
  read_pg_database_line(FILE *fp, char *dbname, Oid *dboid,
! 					  Oid *dbtablespace, TransactionId *dbfrozenxid,
  					  TransactionId *dbvacuumxid)
  {
  	char		buf[MAX_TOKEN];
--- 1013,1019 ----
   */
  bool
  read_pg_database_line(FILE *fp, char *dbname, Oid *dboid,
! 					  Oid *dbtablespace, TransactionId *dbminxid,
  					  TransactionId *dbvacuumxid)
  {
  	char		buf[MAX_TOKEN];
***************
*** 1036,1042 ****
  	next_token(fp, buf, sizeof(buf));
  	if (!isdigit((unsigned char) buf[0]))
  		elog(FATAL, "bad data in flat pg_database file");
! 	*dbfrozenxid = atoxid(buf);
  	next_token(fp, buf, sizeof(buf));
  	if (!isdigit((unsigned char) buf[0]))
  		elog(FATAL, "bad data in flat pg_database file");
--- 1036,1042 ----
  	next_token(fp, buf, sizeof(buf));
  	if (!isdigit((unsigned char) buf[0]))
  		elog(FATAL, "bad data in flat pg_database file");
! 	*dbminxid = atoxid(buf);
  	next_token(fp, buf, sizeof(buf));
  	if (!isdigit((unsigned char) buf[0]))
  		elog(FATAL, "bad data in flat pg_database file");
diff -rc -X diff-ignore 11fixclass/src/backend/postmaster/autovacuum.c 12ntrelminxid/src/backend/postmaster/autovacuum.c
*** 11fixclass/src/backend/postmaster/autovacuum.c	2006-06-10 19:17:47.000000000 -0400
--- 12ntrelminxid/src/backend/postmaster/autovacuum.c	2006-06-10 19:38:04.000000000 -0400
***************
*** 80,86 ****
  {
  	Oid			oid;
  	char	   *name;
! 	TransactionId frozenxid;
  	TransactionId vacuumxid;
  	PgStat_StatDBEntry *entry;
  	int32		age;
--- 80,86 ----
  {
  	Oid			oid;
  	char	   *name;
! 	TransactionId minxid;
  	TransactionId vacuumxid;
  	PgStat_StatDBEntry *entry;
  	int32		age;
***************
*** 350,356 ****
  	{
  		autovac_dbase *tmp = lfirst(cell);
  		bool		this_whole_db;
! 		int32		freeze_age,
  					vacuum_age;
  
  		/*
--- 350,356 ----
  	{
  		autovac_dbase *tmp = lfirst(cell);
  		bool		this_whole_db;
! 		int32		true_age,
  					vacuum_age;
  
  		/*
***************
*** 363,371 ****
  		 * Unlike vacuum.c, we also look at vacuumxid.	This is so that
  		 * pg_clog can be kept trimmed to a reasonable size.
  		 */
! 		freeze_age = (int32) (nextXid - tmp->frozenxid);
  		vacuum_age = (int32) (nextXid - tmp->vacuumxid);
! 		tmp->age = Max(freeze_age, vacuum_age);
  
  		this_whole_db = (tmp->age >
  						 (int32) ((MaxTransactionId >> 3) * 3 - 100000));
--- 363,371 ----
  		 * Unlike vacuum.c, we also look at vacuumxid.	This is so that
  		 * pg_clog can be kept trimmed to a reasonable size.
  		 */
! 		true_age = (int32) (nextXid - tmp->minxid);
  		vacuum_age = (int32) (nextXid - tmp->vacuumxid);
! 		tmp->age = Max(true_age, vacuum_age);
  
  		this_whole_db = (tmp->age >
  						 (int32) ((MaxTransactionId >> 3) * 3 - 100000));
***************
*** 456,462 ****
  	FILE	   *db_file;
  	Oid			db_id;
  	Oid			db_tablespace;
! 	TransactionId db_frozenxid;
  	TransactionId db_vacuumxid;
  
  	filename = database_getflatfilename();
--- 456,462 ----
  	FILE	   *db_file;
  	Oid			db_id;
  	Oid			db_tablespace;
! 	TransactionId db_minxid;
  	TransactionId db_vacuumxid;
  
  	filename = database_getflatfilename();
***************
*** 467,473 ****
  				 errmsg("could not open file \"%s\": %m", filename)));
  
  	while (read_pg_database_line(db_file, thisname, &db_id,
! 								 &db_tablespace, &db_frozenxid,
  								 &db_vacuumxid))
  	{
  		autovac_dbase *db;
--- 467,473 ----
  				 errmsg("could not open file \"%s\": %m", filename)));
  
  	while (read_pg_database_line(db_file, thisname, &db_id,
! 								 &db_tablespace, &db_minxid,
  								 &db_vacuumxid))
  	{
  		autovac_dbase *db;
***************
*** 476,482 ****
  
  		db->oid = db_id;
  		db->name = pstrdup(thisname);
! 		db->frozenxid = db_frozenxid;
  		db->vacuumxid = db_vacuumxid;
  		/* these get set later: */
  		db->entry = NULL;
--- 476,482 ----
  
  		db->oid = db_id;
  		db->name = pstrdup(thisname);
! 		db->minxid = db_minxid;
  		db->vacuumxid = db_vacuumxid;
  		/* these get set later: */
  		db->entry = NULL;
diff -rc -X diff-ignore 11fixclass/src/backend/storage/lmgr/lmgr.c 12ntrelminxid/src/backend/storage/lmgr/lmgr.c
*** 11fixclass/src/backend/storage/lmgr/lmgr.c	2006-05-04 21:36:11.000000000 -0400
--- 12ntrelminxid/src/backend/storage/lmgr/lmgr.c	2006-06-10 22:42:34.000000000 -0400
***************
*** 15,20 ****
--- 15,21 ----
  
  #include "postgres.h"
  
+ #include "access/heapam.h"
  #include "access/subtrans.h"
  #include "access/transam.h"
  #include "access/xact.h"
***************
*** 53,58 ****
--- 54,66 ----
  	LOCKTAG		tag;
  	LockAcquireResult res;
  
+ 	/*
+ 	 * If somebody tries to lock a relation for more than a simple SELECT,
+ 	 * unfreeze it.
+ 	 */
+ 	if (lockmode > AccessShareLock)
+ 		heap_unfreeze(relation);
+ 
  	SET_LOCKTAG_RELATION(tag,
  						 relation->rd_lockInfo.lockRelId.dbId,
  						 relation->rd_lockInfo.lockRelId.relId);
***************
*** 89,94 ****
--- 97,109 ----
  	LOCKTAG		tag;
  	LockAcquireResult res;
  
+ 	/*
+ 	 * If somebody tries to lock a relation for more than a simple SELECT,
+ 	 * unfreeze it.
+ 	 */
+ 	if (lockmode > AccessShareLock)
+ 		heap_unfreeze(relation);
+ 
  	SET_LOCKTAG_RELATION(tag,
  						 relation->rd_lockInfo.lockRelId.dbId,
  						 relation->rd_lockInfo.lockRelId.relId);
diff -rc -X diff-ignore 11fixclass/src/backend/utils/init/flatfiles.c 12ntrelminxid/src/backend/utils/init/flatfiles.c
*** 11fixclass/src/backend/utils/init/flatfiles.c	2006-05-04 21:36:12.000000000 -0400
--- 12ntrelminxid/src/backend/utils/init/flatfiles.c	2006-06-10 19:38:04.000000000 -0400
***************
*** 163,169 ****
  /*
   * write_database_file: update the flat database file
   *
!  * A side effect is to determine the oldest database's datfrozenxid
   * so we can set or update the XID wrap limit.
   */
  static void
--- 163,169 ----
  /*
   * write_database_file: update the flat database file
   *
!  * A side effect is to determine the oldest database's datminxid
   * so we can set or update the XID wrap limit.
   */
  static void
***************
*** 177,183 ****
  	HeapScanDesc scan;
  	HeapTuple	tuple;
  	NameData	oldest_datname;
! 	TransactionId oldest_datfrozenxid = InvalidTransactionId;
  
  	/*
  	 * Create a temporary filename to be renamed later.  This prevents the
--- 177,183 ----
  	HeapScanDesc scan;
  	HeapTuple	tuple;
  	NameData	oldest_datname;
! 	TransactionId oldest_datminxid = InvalidTransactionId;
  
  	/*
  	 * Create a temporary filename to be renamed later.  This prevents the
***************
*** 208,234 ****
  		char	   *datname;
  		Oid			datoid;
  		Oid			dattablespace;
! 		TransactionId datfrozenxid,
  					datvacuumxid;
  
  		datname = NameStr(dbform->datname);
  		datoid = HeapTupleGetOid(tuple);
  		dattablespace = dbform->dattablespace;
! 		datfrozenxid = dbform->datfrozenxid;
  		datvacuumxid = dbform->datvacuumxid;
  
  		/*
! 		 * Identify the oldest datfrozenxid, ignoring databases that are not
  		 * connectable (we assume they are safely frozen).	This must match
  		 * the logic in vac_truncate_clog() in vacuum.c.
  		 */
  		if (dbform->datallowconn &&
! 			TransactionIdIsNormal(datfrozenxid))
  		{
! 			if (oldest_datfrozenxid == InvalidTransactionId ||
! 				TransactionIdPrecedes(datfrozenxid, oldest_datfrozenxid))
  			{
! 				oldest_datfrozenxid = datfrozenxid;
  				namestrcpy(&oldest_datname, datname);
  			}
  		}
--- 208,234 ----
  		char	   *datname;
  		Oid			datoid;
  		Oid			dattablespace;
! 		TransactionId datminxid,
  					datvacuumxid;
  
  		datname = NameStr(dbform->datname);
  		datoid = HeapTupleGetOid(tuple);
  		dattablespace = dbform->dattablespace;
! 		datminxid = dbform->datminxid;
  		datvacuumxid = dbform->datvacuumxid;
  
  		/*
! 		 * Identify the oldest datminxid, ignoring databases that are not
  		 * connectable (we assume they are safely frozen).	This must match
  		 * the logic in vac_truncate_clog() in vacuum.c.
  		 */
  		if (dbform->datallowconn &&
! 			TransactionIdIsNormal(datminxid))
  		{
! 			if (oldest_datminxid == InvalidTransactionId ||
! 				TransactionIdPrecedes(datminxid, oldest_datminxid))
  			{
! 				oldest_datminxid = datminxid;
  				namestrcpy(&oldest_datname, datname);
  			}
  		}
***************
*** 244,257 ****
  		}
  
  		/*
! 		 * The file format is: "dbname" oid tablespace frozenxid vacuumxid
  		 *
  		 * The xids are not needed for backend startup, but are of use to
  		 * autovacuum, and might also be helpful for forensic purposes.
  		 */
  		fputs_quote(datname, fp);
  		fprintf(fp, " %u %u %u %u\n",
! 				datoid, dattablespace, datfrozenxid, datvacuumxid);
  	}
  	heap_endscan(scan);
  
--- 244,257 ----
  		}
  
  		/*
! 		 * The file format is: "dbname" oid tablespace minxid vacuumxid
  		 *
  		 * The xids are not needed for backend startup, but are of use to
  		 * autovacuum, and might also be helpful for forensic purposes.
  		 */
  		fputs_quote(datname, fp);
  		fprintf(fp, " %u %u %u %u\n",
! 				datoid, dattablespace, datminxid, datvacuumxid);
  	}
  	heap_endscan(scan);
  
***************
*** 272,281 ****
  						tempname, filename)));
  
  	/*
! 	 * Set the transaction ID wrap limit using the oldest datfrozenxid
  	 */
! 	if (oldest_datfrozenxid != InvalidTransactionId)
! 		SetTransactionIdLimit(oldest_datfrozenxid, &oldest_datname);
  }
  
  
--- 272,281 ----
  						tempname, filename)));
  
  	/*
! 	 * Set the transaction ID wrap limit using the oldest datminxid
  	 */
! 	if (oldest_datminxid != InvalidTransactionId)
! 		SetTransactionIdLimit(oldest_datminxid, &oldest_datname);
  }
  
  
diff -rc -X diff-ignore 11fixclass/src/backend/utils/init/postinit.c 12ntrelminxid/src/backend/utils/init/postinit.c
*** 11fixclass/src/backend/utils/init/postinit.c	2006-05-04 21:36:12.000000000 -0400
--- 12ntrelminxid/src/backend/utils/init/postinit.c	2006-06-10 19:38:04.000000000 -0400
***************
*** 24,29 ****
--- 24,30 ----
  #include "catalog/pg_authid.h"
  #include "catalog/pg_database.h"
  #include "catalog/pg_tablespace.h"
+ #include "commands/dbcommands.h"
  #include "libpq/hba.h"
  #include "mb/pg_wchar.h"
  #include "miscadmin.h"
***************
*** 193,198 ****
--- 194,210 ----
  					PGC_BACKEND, PGC_S_DEFAULT);
  
  	/*
+ 	 * If the database is marked as frozen, unfreeze it to make sure we won't
+ 	 * leave non-vacuumed tuples hidden behind a frozen pg_database entry.
+ 	 *
+ 	 * This is more paranoid than it needs to be -- if we had a way of
+ 	 * declaring a session as being guaranteed-read-only, we could skip doing
+ 	 * this for such sessions.  In the meantime, be safe.
+ 	 */
+ 	if (TransactionIdEquals(dbform->datminxid, FrozenTransactionId))
+ 		UnfreezeDatabase(MyDatabaseId, GetCurrentTransactionId());
+ 
+ 	/*
  	 * Lastly, set up any database-specific configuration variables.
  	 */
  	if (IsUnderPostmaster)
diff -rc -X diff-ignore 11fixclass/src/backend/utils/mmgr/aset.c 12ntrelminxid/src/backend/utils/mmgr/aset.c
*** 11fixclass/src/backend/utils/mmgr/aset.c	2006-03-08 16:23:32.000000000 -0300
--- 12ntrelminxid/src/backend/utils/mmgr/aset.c	2006-06-11 02:50:35.000000000 -0400
***************
*** 11,17 ****
   * Portions Copyright (c) 1994, Regents of the University of California
   *
   * IDENTIFICATION
!  *	  $PostgreSQL: pgsql/src/backend/utils/mmgr/aset.c,v 1.66 2006-03-05 15:58:49 momjian Exp $
   *
   * NOTE:
   *	This is a new (Feb. 05, 1999) implementation of the allocation set
--- 11,17 ----
   * Portions Copyright (c) 1994, Regents of the University of California
   *
   * IDENTIFICATION
!  *	  $PostgreSQL: pgsql/src/backend/utils/mmgr/aset.c,v 1.66 2006/03/05 15:58:49 momjian Exp $
   *
   * NOTE:
   *	This is a new (Feb. 05, 1999) implementation of the allocation set
diff -rc -X diff-ignore 11fixclass/src/bin/initdb/initdb.c 12ntrelminxid/src/bin/initdb/initdb.c
*** 11fixclass/src/bin/initdb/initdb.c	2006-06-11 17:31:15.000000000 -0400
--- 12ntrelminxid/src/bin/initdb/initdb.c	2006-06-11 17:56:25.000000000 -0400
***************
*** 184,189 ****
--- 184,190 ----
  static void setup_schema(void);
  static void vacuum_db(void);
  static void make_template0(void);
+ static void freeze_template0(void);
  static void make_postgres(void);
  static void trapsig(int signum);
  static void check_ok(void);
***************
*** 2014,2019 ****
--- 2015,2054 ----
  }
  
  /*
+  * freeze template0
+  *
+  * Note that this routine connects to template0, not template1 like all the
+  * rest.
+  */
+ static void
+ freeze_template0(void)
+ {
+ 	PG_CMD_DECL;
+ 	char	  **line;
+ 	static char *template_freeze[] = {
+ 		"VACUUM FREEZE;\n",
+ 		NULL
+ 	};
+ 
+ 	fputs(_("freezing template0 ... "), stdout);
+ 	fflush(stdout);
+ 
+ 	snprintf(cmd, sizeof(cmd),
+ 			 "\"%s\" %s template0 >%s",
+ 			 backend_exec, backend_options,
+ 			 DEVNULL);
+ 
+ 	PG_CMD_OPEN;
+ 
+ 	for (line = template_freeze; *line; line++)
+ 		PG_CMD_PUTS(*line);
+ 
+ 	PG_CMD_CLOSE;
+ 	
+ 	check_ok();
+ }
+ 
+ /*
   * copy template1 to postgres
   */
  static void
***************
*** 2953,2958 ****
--- 2988,2995 ----
  
  	make_template0();
  
+ 	freeze_template0();
+ 
  	make_postgres();
  
  	if (authwarning != NULL)
Sólo en 12ntrelminxid/src/bin/initdb: .#initdb.c.1.116
diff -rc -X diff-ignore 11fixclass/src/include/access/heapam.h 12ntrelminxid/src/include/access/heapam.h
*** 11fixclass/src/include/access/heapam.h	2006-05-13 19:12:34.000000000 -0400
--- 12ntrelminxid/src/include/access/heapam.h	2006-06-10 19:38:04.000000000 -0400
***************
*** 122,127 ****
--- 122,129 ----
  
  /* heapam.c */
  
+ extern bool disable_heap_unfreeze;
+ 
  typedef enum
  {
  	LockTupleShared,
***************
*** 168,173 ****
--- 170,176 ----
  				Buffer *buffer, ItemPointer ctid,
  				TransactionId *update_xmax, CommandId cid,
  				LockTupleMode mode, bool nowait);
+ extern void heap_unfreeze(Relation rel);
  extern void heap_inplace_update(Relation relation, HeapTuple tuple);
  
  extern Oid	simple_heap_insert(Relation relation, HeapTuple tup);
diff -rc -X diff-ignore 11fixclass/src/include/access/transam.h 12ntrelminxid/src/include/access/transam.h
*** 11fixclass/src/include/access/transam.h	2006-03-08 16:23:46.000000000 -0300
--- 12ntrelminxid/src/include/access/transam.h	2006-06-10 19:38:04.000000000 -0400
***************
*** 123,129 ****
  /* in transam/varsup.c */
  extern TransactionId GetNewTransactionId(bool isSubXact);
  extern TransactionId ReadNewTransactionId(void);
! extern void SetTransactionIdLimit(TransactionId oldest_datfrozenxid,
  					  Name oldest_datname);
  extern Oid	GetNewObjectId(void);
  
--- 123,129 ----
  /* in transam/varsup.c */
  extern TransactionId GetNewTransactionId(bool isSubXact);
  extern TransactionId ReadNewTransactionId(void);
! extern void SetTransactionIdLimit(TransactionId oldest_datminxid,
  					  Name oldest_datname);
  extern Oid	GetNewObjectId(void);
  
diff -rc -X diff-ignore 11fixclass/src/include/catalog/pg_attribute.h 12ntrelminxid/src/include/catalog/pg_attribute.h
*** 11fixclass/src/include/catalog/pg_attribute.h	2006-06-09 18:47:58.000000000 -0400
--- 12ntrelminxid/src/include/catalog/pg_attribute.h	2006-06-10 22:45:18.000000000 -0400
***************
*** 442,452 ****
   * ----------------
   */
  #define Schema_pg_ntclass \
! { 1004, {"relpages"},	   23, -1,	4,	1, 0, -1, -1, true, 'p', 'i', true, false, false, true, 0 }, \
! { 1004, {"reltuples"},	   700, -1, 4,	2, 0, -1, -1, false, 'p', 'i', true, false, false, true, 0 }
  
  DATA(insert ( 1004 relpages			23 -1 4   1 0 -1 -1 t p i t f f t 0));
  DATA(insert ( 1004 reltuples	   700 -1 4   2 0 -1 -1 f p i t f f t 0));
  DATA(insert ( 1004 ctid				27 0  6  -1 0 -1 -1 f p s t f f t 0));
  /* no OIDs in pg_ntclass */
  DATA(insert ( 1004 xmin				28 0  4  -3 0 -1 -1 t p i t f f t 0));
--- 442,456 ----
   * ----------------
   */
  #define Schema_pg_ntclass \
! { 1004, {"relpages"},	   23,  -1, 4, 1, 0, -1, -1, true,  'p', 'i', true, false, false, true, 0 }, \
! { 1004, {"reltuples"},	   700, -1, 4, 2, 0, -1, -1, false, 'p', 'i', true, false, false, true, 0 }, \
! { 1004, {"relminxid"},	   28,  -1, 4, 3, 0, -1, -1, true,  'p', 'i', true, false, false, true, 0 }, \
! { 1004, {"relvacuumxid"},  28,  -1, 4, 4, 0, -1, -1, true,  'p', 'i', true, false, false, true, 0 }
  
  DATA(insert ( 1004 relpages			23 -1 4   1 0 -1 -1 t p i t f f t 0));
  DATA(insert ( 1004 reltuples	   700 -1 4   2 0 -1 -1 f p i t f f t 0));
+ DATA(insert ( 1004 relminxid		28 -1 4   3 0 -1 -1 t p i t f f t 0));
+ DATA(insert ( 1004 relvacuumxid		28 -1 4   4 0 -1 -1 t p i t f f t 0));
  DATA(insert ( 1004 ctid				27 0  6  -1 0 -1 -1 f p s t f f t 0));
  /* no OIDs in pg_ntclass */
  DATA(insert ( 1004 xmin				28 0  4  -3 0 -1 -1 t p i t f f t 0));
diff -rc -X diff-ignore 11fixclass/src/include/catalog/pg_class.h 12ntrelminxid/src/include/catalog/pg_class.h
*** 11fixclass/src/include/catalog/pg_class.h	2006-06-10 18:10:25.000000000 -0400
--- 12ntrelminxid/src/include/catalog/pg_class.h	2006-06-11 01:42:29.000000000 -0400
***************
*** 149,155 ****
  DESCR("");
  DATA(insert OID = 1259 (  pg_class		PGNSP 83 PGUID 0 1259 0 0 0 "(0,4)" f f r 24 0 0 0 0 0 t f f f _null_ ));
  DESCR("");
! DATA(insert OID = 1004 (  pg_ntclass	PGNSP 86 PGUID 0 1004 0 0 0 "(0,5)" f f n  2 0 0 0 0 0 f f f f _null_ ));
  DESCR("");
  
  #define		  RELKIND_INDEX			  'i'		/* secondary index */
--- 149,155 ----
  DESCR("");
  DATA(insert OID = 1259 (  pg_class		PGNSP 83 PGUID 0 1259 0 0 0 "(0,4)" f f r 24 0 0 0 0 0 t f f f _null_ ));
  DESCR("");
! DATA(insert OID = 1004 (  pg_ntclass	PGNSP 86 PGUID 0 1004 0 0 0 "(0,5)" f f n  4 0 0 0 0 0 f f f f _null_ ));
  DESCR("");
  
  #define		  RELKIND_INDEX			  'i'		/* secondary index */
diff -rc -X diff-ignore 11fixclass/src/include/catalog/pg_database.h 12ntrelminxid/src/include/catalog/pg_database.h
*** 11fixclass/src/include/catalog/pg_database.h	2006-03-08 16:23:46.000000000 -0300
--- 12ntrelminxid/src/include/catalog/pg_database.h	2006-06-10 22:39:48.000000000 -0400
***************
*** 43,49 ****
  	int4		datconnlimit;	/* max connections allowed (-1=no limit) */
  	Oid			datlastsysoid;	/* highest OID to consider a system OID */
  	TransactionId datvacuumxid; /* all XIDs before this are vacuumed */
! 	TransactionId datfrozenxid; /* all XIDs before this are frozen */
  	Oid			dattablespace;	/* default table space for this DB */
  	text		datconfig[1];	/* database-specific GUC (VAR LENGTH) */
  	aclitem		datacl[1];		/* access permissions (VAR LENGTH) */
--- 43,49 ----
  	int4		datconnlimit;	/* max connections allowed (-1=no limit) */
  	Oid			datlastsysoid;	/* highest OID to consider a system OID */
  	TransactionId datvacuumxid; /* all XIDs before this are vacuumed */
! 	TransactionId datminxid;	/* minimum XID present anywhere in the DB */
  	Oid			dattablespace;	/* default table space for this DB */
  	text		datconfig[1];	/* database-specific GUC (VAR LENGTH) */
  	aclitem		datacl[1];		/* access permissions (VAR LENGTH) */
***************
*** 69,75 ****
  #define Anum_pg_database_datconnlimit	6
  #define Anum_pg_database_datlastsysoid	7
  #define Anum_pg_database_datvacuumxid	8
! #define Anum_pg_database_datfrozenxid	9
  #define Anum_pg_database_dattablespace	10
  #define Anum_pg_database_datconfig		11
  #define Anum_pg_database_datacl			12
--- 69,75 ----
  #define Anum_pg_database_datconnlimit	6
  #define Anum_pg_database_datlastsysoid	7
  #define Anum_pg_database_datvacuumxid	8
! #define Anum_pg_database_datminxid		9
  #define Anum_pg_database_dattablespace	10
  #define Anum_pg_database_datconfig		11
  #define Anum_pg_database_datacl			12
diff -rc -X diff-ignore 11fixclass/src/include/catalog/pg_ntclass.h 12ntrelminxid/src/include/catalog/pg_ntclass.h
*** 11fixclass/src/include/catalog/pg_ntclass.h	2006-06-10 22:21:01.000000000 -0400
--- 12ntrelminxid/src/include/catalog/pg_ntclass.h	2006-06-11 01:33:58.000000000 -0400
***************
*** 38,48 ****
  {
  	int4		relpages;		/* # of blocks (not always up-to-date) */
  	float4		reltuples;		/* # of tuples (not always up-to-date) */
  } FormData_pg_ntclass;
  
  /* Size of pg_ntclass tuples */
  #define NTCLASS_TUPLE_SIZE \
! 	 (offsetof(FormData_pg_ntclass,reltuples) + sizeof(float4))
  /* ----------------
   *		Form_pg_ntclass corresponds to a pointer to a tuple with
   *		the format of pg_ntclass relation.
--- 38,50 ----
  {
  	int4		relpages;		/* # of blocks (not always up-to-date) */
  	float4		reltuples;		/* # of tuples (not always up-to-date) */
+ 	TransactionId relminxid;	/* minimum Xid present in table */
+ 	TransactionId relvacuumxid;	/* cutoff point used at last VACUUM */
  } FormData_pg_ntclass;
  
  /* Size of pg_ntclass tuples */
  #define NTCLASS_TUPLE_SIZE \
! 	 (offsetof(FormData_pg_ntclass,relvacuumxid) + sizeof(TransactionId))
  /* ----------------
   *		Form_pg_ntclass corresponds to a pointer to a tuple with
   *		the format of pg_ntclass relation.
***************
*** 54,62 ****
   *		compiler constants for pg_ntclass
   * ----------------
   */
! #define Natts_pg_ntclass				2
  #define Anum_pg_ntclass_relpages		1
  #define Anum_pg_ntclass_reltuples		2
  
  /* ----------------
   *		initial contents of pg_ntclass
--- 56,66 ----
   *		compiler constants for pg_ntclass
   * ----------------
   */
! #define Natts_pg_ntclass				4
  #define Anum_pg_ntclass_relpages		1
  #define Anum_pg_ntclass_reltuples		2
+ #define Anum_pg_ntclass_relminxid		3
+ #define Anum_pg_ntclass_relvacuumxid	4
  
  /* ----------------
   *		initial contents of pg_ntclass
***************
*** 66,75 ****
   * ----------------
   */
  
! DATA(insert ( 0 0 ));
! DATA(insert ( 0 0 ));
! DATA(insert ( 0 0 ));
! DATA(insert ( 0 0 ));
! DATA(insert ( 0 0 ));
  
  #endif   /* PG_NTCLASS_H */
--- 70,79 ----
   * ----------------
   */
  
! DATA(insert ( 0 0 0 0 ));
! DATA(insert ( 0 0 0 0 ));
! DATA(insert ( 0 0 0 0 ));
! DATA(insert ( 0 0 0 0 ));
! DATA(insert ( 0 0 0 0 ));
  
  #endif   /* PG_NTCLASS_H */
diff -rc -X diff-ignore 11fixclass/src/include/commands/dbcommands.h 12ntrelminxid/src/include/commands/dbcommands.h
*** 11fixclass/src/include/commands/dbcommands.h	2006-05-04 21:36:12.000000000 -0400
--- 12ntrelminxid/src/include/commands/dbcommands.h	2006-06-10 19:38:04.000000000 -0400
***************
*** 58,63 ****
--- 58,64 ----
  extern void AlterDatabase(AlterDatabaseStmt *stmt);
  extern void AlterDatabaseSet(AlterDatabaseSetStmt *stmt);
  extern void AlterDatabaseOwner(const char *dbname, Oid newOwnerId);
+ extern void UnfreezeDatabase(Oid dbid, TransactionId unfreezeXid);
  
  extern Oid	get_database_oid(const char *dbname);
  extern char *get_database_name(Oid dbid);
diff -rc -X diff-ignore 11fixclass/src/include/commands/vacuum.h 12ntrelminxid/src/include/commands/vacuum.h
*** 11fixclass/src/include/commands/vacuum.h	2006-06-04 22:36:52.000000000 -0400
--- 12ntrelminxid/src/include/commands/vacuum.h	2006-06-10 20:22:17.000000000 -0400
***************
*** 114,123 ****
  extern void vac_open_indexes(Relation relation, LOCKMODE lockmode,
  				 int *nindexes, Relation **Irel);
  extern void vac_close_indexes(int nindexes, Relation *Irel, LOCKMODE lockmode);
! extern void vac_update_relstats(Relation rel,
! 					BlockNumber num_pages,
! 					double num_tuples,
! 					bool hasindex);
  extern void vacuum_set_xid_limits(VacuumStmt *vacstmt, bool sharedRel,
  					  TransactionId *oldestXmin,
  					  TransactionId *freezeLimit);
--- 114,122 ----
  extern void vac_open_indexes(Relation relation, LOCKMODE lockmode,
  				 int *nindexes, Relation **Irel);
  extern void vac_close_indexes(int nindexes, Relation *Irel, LOCKMODE lockmode);
! extern void vac_update_relstats(Relation rel, BlockNumber num_pages,
! 					double num_tuples, bool hasindex,
! 					TransactionId minxid, TransactionId vacuumxid);
  extern void vacuum_set_xid_limits(VacuumStmt *vacstmt, bool sharedRel,
  					  TransactionId *oldestXmin,
  					  TransactionId *freezeLimit);
diff -rc -X diff-ignore 11fixclass/src/include/libpq/hba.h 12ntrelminxid/src/include/libpq/hba.h
*** 11fixclass/src/include/libpq/hba.h	2006-03-08 16:23:47.000000000 -0300
--- 12ntrelminxid/src/include/libpq/hba.h	2006-06-10 19:38:04.000000000 -0400
***************
*** 40,46 ****
  extern int	hba_getauthmethod(hbaPort *port);
  extern int	authident(hbaPort *port);
  extern bool read_pg_database_line(FILE *fp, char *dbname, Oid *dboid,
! 					  Oid *dbtablespace, TransactionId *dbfrozenxid,
  					  TransactionId *dbvacuumxid);
  
  #endif   /* HBA_H */
--- 40,46 ----
  extern int	hba_getauthmethod(hbaPort *port);
  extern int	authident(hbaPort *port);
  extern bool read_pg_database_line(FILE *fp, char *dbname, Oid *dboid,
! 					  Oid *dbtablespace, TransactionId *dbminxid,
  					  TransactionId *dbvacuumxid);
  
  #endif   /* HBA_H */

Index: doc/src/sgml/catalogs.sgml
===================================================================
RCS file: /home/alvherre/cvs/pgsql/doc/src/sgml/catalogs.sgml,v
retrieving revision 2.124
diff -c -r2.124 catalogs.sgml
*** doc/src/sgml/catalogs.sgml	3 Jun 2006 02:53:04 -0000	2.124
--- doc/src/sgml/catalogs.sgml	12 Jun 2006 03:16:08 -0000
***************
*** 104,109 ****
--- 104,114 ----
       </row>
  
       <row>
+       <entry><link linkend="catalog-pg-class-nt"><structname>pg_class_nt</structname></link></entry>
+       <entry>non-transactional columns for <structname>pg_class</structname></entry>
+      </row>
+ 
+      <row>
        <entry><link linkend="catalog-pg-constraint"><structname>pg_constraint</structname></link></entry>
        <entry>check constraints, unique constraints, primary key constraints, foreign key constraints</entry>
       </row>
***************
*** 1465,1497 ****
       </row>
  
       <row>
-       <entry><structfield>relpages</structfield></entry>
-       <entry><type>int4</type></entry>
-       <entry></entry>
-       <entry>
-        Size of the on-disk representation of this table in pages (of size
-        <symbol>BLCKSZ</symbol>).
-        This is only an estimate used by the planner.
-        It is updated by <command>VACUUM</command>,
-        <command>ANALYZE</command>, and a few DDL commands
-        such as <command>CREATE INDEX</command>.
-       </entry>
-      </row>
- 
-      <row>
-       <entry><structfield>reltuples</structfield></entry>
-       <entry><type>float4</type></entry>
-       <entry></entry>
-       <entry>
-        Number of rows in the table.
-        This is only an estimate used by the planner.
-        It is updated by <command>VACUUM</command>,
-        <command>ANALYZE</command>, and a few DDL commands
-        such as <command>CREATE INDEX</command>.
-       </entry>
-      </row>
- 
-      <row>
        <entry><structfield>reltoastrelid</structfield></entry>
        <entry><type>oid</type></entry>
        <entry><literal><link linkend="catalog-pg-class"><structname>pg_class</structname></link>.oid</literal></entry>
--- 1470,1475 ----
***************
*** 1512,1517 ****
--- 1490,1504 ----
       </row>
  
       <row>
+       <entry><structfield>relntrans</structfield></entry>
+       <entry><type>tid</type></entry>
+       <entry><literal><link linkend="catalog-pg-class-nt"><structname>pg_class_nt</structname></link>.ctid</literal></entry>
+       <entry>
+        CTID of this relation's pg_class_nt row.
+       </entry>
+      </row>
+ 
+      <row>
        <entry><structfield>relhasindex</structfield></entry>
        <entry><type>bool</type></entry>
        <entry></entry>
***************
*** 1538,1547 ****
        <entry><type>char</type></entry>
        <entry></entry>
        <entry>
!        <literal>r</> = ordinary table, <literal>i</> = index,
!        <literal>S</> = sequence, <literal>v</> = view, <literal>c</> =
!        composite type, <literal>t</> = TOAST
!        table
        </entry>
       </row>
  
--- 1525,1533 ----
        <entry><type>char</type></entry>
        <entry></entry>
        <entry>
!        <literal>r</> = ordinary table, <literal>i</> = index, <literal>S</> =
!        sequence, <literal>v</> = view, <literal>c</> = composite type,
!        <literal>t</> = TOAST table, <literal>n</> = non-transactional catalog
        </entry>
       </row>
  
***************
*** 1648,1653 ****
--- 1634,1695 ----
    </table>
   </sect1>
  
+  <sect1 id="catalog-pg-class-nt">
+   <title><structname>pg_class_nt</structname></title>
+ 
+   <indexterm zone="catalog-pg-class-nt">
+    <primary>pg_class_nt</primary>
+   </indexterm>
+ 
+   <para>
+    The catalog <structname>pg_class_nt</structname> stores the non-transactional
+    information about <structname>pg_class</structname> entries, that is, the
+    information that is independent of the commit status of any particular
+    transaction.
+   </para>
+ 
+   <table>
+    <title><structname>pg_class_nt</> Columns</title>
+ 
+    <tgroup cols=4>
+     <thead>
+      <row>
+       <entry>Name</entry>
+       <entry>Type</entry>
+       <entry>References</entry>
+       <entry>Description</entry>
+      </row>
+     </thead>
+ 
+     <tbody>
+      <row>
+       <entry><structfield>npages</structfield></entry>
+       <entry><type>int4</type></entry>
+       <entry></entry>
+       <entry>
+        Size of the on-disk representation of this table in pages (of size
+        <symbol>BLCKSZ</symbol>).  This is only an estimate used by the planner.
+        It is updated by <command>VACUUM</command>, <command>ANALYZE</command>,
+        and a few DDL commands such as <command>CREATE INDEX</command>.
+       </entry>
+      </row>
+ 
+      <row>
+       <entry><structfield>ntuples</structfield></entry>
+       <entry><type>float4</type></entry>
+       <entry></entry>
+       <entry>
+        Number of rows in the table.  This is only an estimate used by the
+        planner.  It is updated by <command>VACUUM</command>,
+        <command>ANALYZE</command>, and a few DDL commands such as
+        <command>CREATE INDEX</command>.
+       </entry>
+      </row>
+     </tbody>
+   </tgroup>
+  </sect1>
+ 
+ 
   <sect1 id="catalog-pg-constraint">
    <title><structname>pg_constraint</structname></title>
  
Index: src/backend/access/heap/heapam.c
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/access/heap/heapam.c,v
retrieving revision 1.213
diff -c -r1.213 heapam.c
*** src/backend/access/heap/heapam.c	28 May 2006 02:27:08 -0000	1.213
--- src/backend/access/heap/heapam.c	10 Jun 2006 23:17:47 -0000
***************
*** 1828,1833 ****
--- 1828,1839 ----
  
  	Assert(ItemPointerIsValid(otid));
  
+ 	if (relation->rd_rel->relkind == RELKIND_NON_TRANSACTIONAL)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ 				 errmsg("can't update non-transactional catalog %s",
+ 					   RelationGetRelationName(relation))));
+ 
  	buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(otid));
  	LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
  
Index: src/backend/catalog/Makefile
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/catalog/Makefile,v
retrieving revision 1.59
diff -c -r1.59 Makefile
*** src/backend/catalog/Makefile	12 Feb 2006 03:22:17 -0000	1.59
--- src/backend/catalog/Makefile	12 Jun 2006 16:39:21 -0000
***************
*** 24,33 ****
  
  # Note: there are some undocumented dependencies on the ordering in which
  # the catalog header files are assembled into postgres.bki.  In particular,
! # indexing.h had better be last.
  
  POSTGRES_BKI_SRCS := $(addprefix $(top_srcdir)/src/include/catalog/,\
! 	pg_proc.h pg_type.h pg_attribute.h pg_class.h pg_autovacuum.h \
  	pg_attrdef.h pg_constraint.h pg_inherits.h pg_index.h \
  	pg_operator.h pg_opclass.h pg_am.h pg_amop.h pg_amproc.h \
  	pg_language.h pg_largeobject.h pg_aggregate.h pg_statistic.h \
--- 24,34 ----
  
  # Note: there are some undocumented dependencies on the ordering in which
  # the catalog header files are assembled into postgres.bki.  In particular,
! # indexing.h had better be last, and the bootstrapped catalogs must appear in
! # front.
  
  POSTGRES_BKI_SRCS := $(addprefix $(top_srcdir)/src/include/catalog/,\
! 	pg_proc.h pg_type.h pg_attribute.h pg_class.h pg_class_nt.h pg_autovacuum.h \
  	pg_attrdef.h pg_constraint.h pg_inherits.h pg_index.h \
  	pg_operator.h pg_opclass.h pg_am.h pg_amop.h pg_amproc.h \
  	pg_language.h pg_largeobject.h pg_aggregate.h pg_statistic.h \
Index: src/backend/catalog/heap.c
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/catalog/heap.c,v
retrieving revision 1.299
diff -c -r1.299 heap.c
*** src/backend/catalog/heap.c	10 May 2006 23:18:39 -0000	1.299
--- src/backend/catalog/heap.c	12 Jun 2006 03:56:23 -0000
***************
*** 37,42 ****
--- 37,43 ----
  #include "catalog/index.h"
  #include "catalog/indexing.h"
  #include "catalog/pg_attrdef.h"
+ #include "catalog/pg_class_nt.h"
  #include "catalog/pg_constraint.h"
  #include "catalog/pg_inherits.h"
  #include "catalog/pg_namespace.h"
***************
*** 66,71 ****
--- 67,73 ----
  					Relation new_rel_desc,
  					Oid new_rel_oid, Oid new_type_oid,
  					Oid relowner,
+ 					ItemPointerData nttid,
  					char relkind);
  static Oid AddNewRelationType(const char *typeName,
  				   Oid typeNamespace,
***************
*** 557,562 ****
--- 559,565 ----
  					Oid new_rel_oid,
  					Oid new_type_oid,
  					Oid relowner,
+ 					ItemPointerData nttid,
  					char relkind)
  {
  	Form_pg_class new_rel_reltup;
***************
*** 568,597 ****
  	 */
  	new_rel_reltup = new_rel_desc->rd_rel;
  
- 	switch (relkind)
- 	{
- 		case RELKIND_RELATION:
- 		case RELKIND_INDEX:
- 		case RELKIND_TOASTVALUE:
- 			/* The relation is real, but as yet empty */
- 			new_rel_reltup->relpages = 0;
- 			new_rel_reltup->reltuples = 0;
- 			break;
- 		case RELKIND_SEQUENCE:
- 			/* Sequences always have a known size */
- 			new_rel_reltup->relpages = 1;
- 			new_rel_reltup->reltuples = 1;
- 			break;
- 		default:
- 			/* Views, etc, have no disk storage */
- 			new_rel_reltup->relpages = 0;
- 			new_rel_reltup->reltuples = 0;
- 			break;
- 	}
- 
  	new_rel_reltup->relowner = relowner;
  	new_rel_reltup->reltype = new_type_oid;
  	new_rel_reltup->relkind = relkind;
  
  	new_rel_desc->rd_att->tdtypeid = new_type_oid;
  
--- 571,580 ----
  	 */
  	new_rel_reltup = new_rel_desc->rd_rel;
  
  	new_rel_reltup->relowner = relowner;
  	new_rel_reltup->reltype = new_type_oid;
  	new_rel_reltup->relkind = relkind;
+ 	new_rel_reltup->relntrans = nttid;
  
  	new_rel_desc->rd_att->tdtypeid = new_type_oid;
  
***************
*** 618,623 ****
--- 601,684 ----
  	heap_freetuple(tup);
  }
  
+ /*
+  * AddNewNtClassTuple
+  *
+  * Insert a pg_class_nt tuple for the given relation, and return its
+  * TID.
+  */
+ ItemPointerData
+ AddNewNtClassTuple(Relation new_rel_desc, char relkind)
+ {
+ 	ItemPointerData	tid;
+ 
+ 	/*
+ 	 * We don't create pg_class_nt entries for sequences, views or composite
+ 	 * types, because they don't have variable-size storage and thus they don't
+ 	 * need it.
+ 	 */
+ 	if (relkind == RELKIND_VIEW ||
+ 		relkind == RELKIND_COMPOSITE_TYPE ||
+ 		relkind == RELKIND_SEQUENCE)
+ 	{
+ 		ItemPointerSetInvalid(&tid);
+ 	}
+ 	else
+ 	{
+ 		Relation	ntRel;
+ 		Form_pg_class_nt new_rel_nttup;
+ 		HeapTuple	tup;
+ 
+ 		ntRel = heap_open(NtClassRelationId, RowExclusiveLock);
+ 
+ 		new_rel_nttup = (Form_pg_class_nt) palloc(sizeof(FormData_pg_class_nt));
+ 
+ 		/* choose the appropiate new values we want to insert */
+ 		switch (relkind)
+ 		{
+ 			case RELKIND_RELATION:
+ 			case RELKIND_INDEX:
+ 			case RELKIND_TOASTVALUE:
+ 			case RELKIND_NON_TRANSACTIONAL:
+ 				/* The relation is real, but as yet empty */
+ 				new_rel_nttup->npages = 0;
+ 				new_rel_nttup->ntuples = 0;
+ 				break;
+ 			default:
+ 				elog(ERROR, "can't create pg_class_nt entries for relkind '%c'",
+ 					 relkind);
+ 				break;
+ 		}
+ 
+ 		/*
+ 		 * now form a tuple to add to pg_class_nt
+ 		 */
+ 		tup = heap_addheader(Natts_pg_class_nt,
+ 							 false,
+ 							 NTCLASS_TUPLE_SIZE,
+ 							 (void *) new_rel_nttup);
+ 
+ 		/*
+ 		 * finally insert the new tuple, update the indexes, and clean up.
+ 		 */
+ 		simple_heap_insert(ntRel, tup);
+ 
+ 		/* Grab the newly inserted tuple's TID for saving it into pg_class */
+ 		tid = tup->t_self;
+ 
+ #ifdef NOT_USED
+ 		/* pg_class_nt does not have indexes */
+ 		CatalogUpdateIndexes(ntRel, tup);
+ #endif
+ 
+ 		heap_close(ntRel, RowExclusiveLock);
+ 
+ 		heap_freetuple(tup);
+ 		pfree(new_rel_nttup);
+ 	}
+ 
+ 	return tid;
+ }
  
  /* --------------------------------
   *		AddNewRelationType -
***************
*** 679,684 ****
--- 740,747 ----
  	Relation	pg_class_desc;
  	Relation	new_rel_desc;
  	Oid			new_type_oid;
+ 	ItemPointerData nttid;
+ 
  
  	pg_class_desc = heap_open(RelationRelationId, RowExclusiveLock);
  
***************
*** 733,738 ****
--- 796,806 ----
  									  relkind);
  
  	/*
+ 	 * Create a pg_class_nt entry for the relation.
+ 	 */
+ 	nttid = AddNewNtClassTuple(new_rel_desc, relkind);
+ 
+ 	/*
  	 * now create an entry in pg_class for the relation.
  	 *
  	 * NOTE: we could get a unique-index failure here, in case someone else is
***************
*** 744,749 ****
--- 812,818 ----
  						relid,
  						new_type_oid,
  						ownerid,
+ 						nttid,
  						relkind);
  
  	/*
***************
*** 872,877 ****
--- 941,962 ----
  	heap_close(pg_class_desc, RowExclusiveLock);
  }
  
+ void
+ DeleteNtClassTuple(ItemPointer tid)
+ {
+ 	Relation	pg_class_nt;
+ 
+ 	/* some relations don't have pg_class_nt tuples */
+ 	if (!ItemPointerIsValid(tid))
+ 		return;
+ 
+ 	pg_class_nt = heap_open(NtClassRelationId, RowExclusiveLock);
+ 
+ 	simple_heap_delete(pg_class_nt, tid);
+ 
+ 	heap_close(pg_class_nt, RowExclusiveLock);
+ }
+ 
  /*
   *		DeleteAttributeTuples
   *
***************
*** 1159,1164 ****
--- 1244,1252 ----
  		smgrscheduleunlink(rel->rd_smgr, rel->rd_istemp);
  	}
  
+ 	/* Delete the pg_class_nt tuple */
+ 	DeleteNtClassTuple(&(rel->rd_rel->relntrans));
+ 
  	/*
  	 * Close relcache entry, but *keep* AccessExclusiveLock on the relation
  	 * until transaction commit.  This ensures no one else will try to do
***************
*** 2133,2135 ****
--- 2221,2293 ----
  
  	return result;
  }
+ 
+ /*
+  * Return the number of tuples and pages for a given relation, as recorded in
+  * its pg_class_nt entry.  ntuples and npages are output parameters, and can be
+  * NULL if the caller does not need them.
+  */
+ void
+ relation_get_ntups_npages(Relation relation, float4 *ntuples, int4 *npages)
+ {
+ 	HeapTuple	tup;
+ 	Relation	pg_class_nt;
+ 	Form_pg_class_nt ntForm;
+ 
+ 	pg_class_nt = heap_open(NtClassRelationId, AccessShareLock);
+ 
+ 	tup = get_class_nt_entry(pg_class_nt, relation);
+ 	ntForm = (Form_pg_class_nt) GETSTRUCT(tup);
+ 
+ 	if (ntuples != NULL)
+ 		*ntuples = ntForm->ntuples;
+ 	if (npages != NULL)
+ 		*npages = ntForm->npages;
+ 
+ 	heap_freetuple(tup);
+ 	heap_close(pg_class_nt, AccessShareLock);
+ }
+ 
+ /*
+  * get_class_nt_entry
+  *		Return a copy of the pg_class_nt tuple for the given target relation.
+  *
+  * The first argument is the pg_class_nt relation, already open and suitably
+  * locked.  If the caller is going to call update_class_nt_entry later, it
+  * must be locked with at least RowExclusiveLock.
+  */
+ HeapTuple
+ get_class_nt_entry(Relation pg_class_nt, Relation target)
+ {
+ 	HeapTupleData tuple;
+ 	HeapTuple	retval;
+ 	Buffer		buffer;
+ 
+ 	Assert(ItemPointerIsValid(&(target->rd_rel->relntrans)));
+ 
+ 	tuple.t_self = target->rd_rel->relntrans;
+ 
+ 	if (!heap_fetch(pg_class_nt, SnapshotNow, &tuple, &buffer, false, NULL))
+ 		elog(ERROR, "lookup failed for pg_class_nt entry for relation %s",
+ 			 RelationGetRelationName(target));
+ 
+ 	retval = heap_copytuple(&tuple);
+ 	ReleaseBuffer(buffer);
+ 
+ 	return retval;
+ }
+ 
+ /*
+  * update_class_nt_entry
+  * 		Update a given pg_class_nt entry.
+  *
+  * The passed tuple should have been obtained by get_class_nt_entry.
+  */
+ void
+ update_class_nt_entry(Relation pg_class_nt, HeapTuple tuple)
+ {
+ 	elog(DEBUG2, "updating pg_class_nt entry (%u/%u)",
+ 		 ItemPointerGetBlockNumber(&(tuple->t_self)),
+ 		 ItemPointerGetOffsetNumber(&(tuple->t_self)));
+ 	heap_inplace_update(pg_class_nt, tuple);
+ }
Index: src/backend/catalog/index.c
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/catalog/index.c,v
retrieving revision 1.266
diff -c -r1.266 index.c
*** src/backend/catalog/index.c	10 May 2006 23:18:39 -0000	1.266
--- src/backend/catalog/index.c	12 Jun 2006 16:30:11 -0000
***************
*** 31,36 ****
--- 31,37 ----
  #include "catalog/heap.h"
  #include "catalog/index.h"
  #include "catalog/indexing.h"
+ #include "catalog/pg_class_nt.h"
  #include "catalog/pg_constraint.h"
  #include "catalog/pg_opclass.h"
  #include "catalog/pg_type.h"
***************
*** 569,575 ****
  
  	/*
  	 * Fill in fields of the index's pg_class entry that are not set correctly
! 	 * by heap_create.
  	 *
  	 * XXX should have a cleaner way to create cataloged indexes
  	 */
--- 570,576 ----
  
  	/*
  	 * Fill in fields of the index's pg_class entry that are not set correctly
! 	 * by heap_create, and create the pg_class_nt entry.
  	 *
  	 * XXX should have a cleaner way to create cataloged indexes
  	 */
***************
*** 577,582 ****
--- 578,585 ----
  	indexRelation->rd_rel->relam = accessMethodObjectId;
  	indexRelation->rd_rel->relkind = RELKIND_INDEX;
  	indexRelation->rd_rel->relhasoids = false;
+ 	indexRelation->rd_rel->relntrans =
+ 		AddNewNtClassTuple(indexRelation, RELKIND_INDEX);
  
  	/*
  	 * store index's pg_class entry
***************
*** 756,761 ****
--- 759,768 ----
  	}
  	else if (skip_build)
  	{
+ 		float4 ntuples;
+ 
+ 		relation_get_ntups_npages(heapRelation, &ntuples, NULL);
+ 
  		/*
  		 * Caller is responsible for filling the index later on.  However,
  		 * we'd better make sure that the heap relation is correctly marked
***************
*** 765,771 ****
  						   true,
  						   isprimary,
  						   InvalidOid,
! 						   heapRelation->rd_rel->reltuples);
  		/* Make the above update visible */
  		CommandCounterIncrement();
  	}
--- 772,778 ----
  						   true,
  						   isprimary,
  						   InvalidOid,
! 						   ntuples);
  		/* Make the above update visible */
  		CommandCounterIncrement();
  	}
***************
*** 826,831 ****
--- 833,841 ----
  	smgrscheduleunlink(userIndexRelation->rd_smgr,
  					   userIndexRelation->rd_istemp);
  
+ 	/* delete pg_class_nt tuple */
+ 	DeleteNtClassTuple(&(userIndexRelation->rd_rel->relntrans));
+ 
  	/*
  	 * Close and flush the index's relcache entry, to ensure relcache doesn't
  	 * try to rebuild it while we're deleting catalog entries. We keep the
***************
*** 1011,1027 ****
  /*
   * index_update_stats --- update pg_class entry after CREATE INDEX
   *
!  * This routine updates the pg_class row of either an index or its parent
!  * relation after CREATE INDEX.  Its rather bizarre API is designed to
!  * ensure we can do all the necessary work in just one update.
   *
   * hasindex: set relhasindex to this value
   * isprimary: if true, set relhaspkey true; else no change
   * reltoastidxid: if not InvalidOid, set reltoastidxid to this value;
   *		else no change
!  * reltuples: set reltuples to this value
   *
!  * relpages is also updated (using RelationGetNumberOfBlocks()).
   *
   * NOTE: an important side-effect of this operation is that an SI invalidation
   * message is sent out to all backends --- including me --- causing relcache
--- 1021,1037 ----
  /*
   * index_update_stats --- update pg_class entry after CREATE INDEX
   *
!  * This routine updates the pg_class and pg_class_nt rows of either an index or
!  * its parent relation after CREATE INDEX.  Its rather bizarre API is designed
!  * to ensure we can do all the necessary work in just one update.
   *
   * hasindex: set relhasindex to this value
   * isprimary: if true, set relhaspkey true; else no change
   * reltoastidxid: if not InvalidOid, set reltoastidxid to this value;
   *		else no change
!  * pg_class_nt.ntuples: set reltuples to this value
   *
!  * pg_class_nt.npages is also updated (using RelationGetNumberOfBlocks()).
   *
   * NOTE: an important side-effect of this operation is that an SI invalidation
   * message is sent out to all backends --- including me --- causing relcache
***************
*** 1038,1045 ****
--- 1048,1057 ----
  	BlockNumber	relpages = RelationGetNumberOfBlocks(rel);
  	Oid			relid = RelationGetRelid(rel);
  	Relation	pg_class;
+ 	Relation	pg_class_nt;
  	HeapTuple	tuple;
  	Form_pg_class rd_rel;
+ 	Form_pg_class_nt ntForm;
  	bool		in_place_upd;
  	bool		dirty;
  
***************
*** 1112,1127 ****
  			dirty = true;
  		}
  	}
- 	if (rd_rel->reltuples != (float4) reltuples)
- 	{
- 		rd_rel->reltuples = (float4) reltuples;
- 		dirty = true;
- 	}
- 	if (rd_rel->relpages != (int32) relpages)
- 	{
- 		rd_rel->relpages = (int32) relpages;
- 		dirty = true;
- 	}
  
  	/*
  	 * If anything changed, write out the tuple
--- 1124,1129 ----
***************
*** 1185,1190 ****
--- 1187,1216 ----
  	heap_freetuple(tuple);
  
  	heap_close(pg_class, RowExclusiveLock);
+ 
+ 	/* update the non-transactional (pg_class_nt) entry */
+ 	pg_class_nt = heap_open(NtClassRelationId, RowExclusiveLock);
+ 
+ 	tuple = get_class_nt_entry(pg_class_nt, rel);
+ 
+ 	ntForm = (Form_pg_class_nt) GETSTRUCT(tuple);
+ 
+ 	dirty = false;
+ 	if (ntForm->ntuples != (float4) reltuples)
+ 	{
+ 		ntForm->ntuples = (float4) reltuples;
+ 		dirty = true;
+ 	}
+ 	if (ntForm->npages != (int32) relpages)
+ 	{
+ 		ntForm->npages = (int32) relpages;
+ 		dirty = true;
+ 	}
+ 	if (dirty)
+ 		update_class_nt_entry(pg_class_nt, tuple);
+ 	heap_freetuple(tuple);
+ 
+ 	heap_close(pg_class_nt, RowExclusiveLock);
  }
  
  /*
***************
*** 1240,1249 ****
  	RelationOpenSmgr(relation);
  	smgrscheduleunlink(relation->rd_smgr, relation->rd_istemp);
  
! 	/* update the pg_class row */
  	rd_rel->relfilenode = newrelfilenode;
- 	rd_rel->relpages = 0;		/* it's empty until further notice */
- 	rd_rel->reltuples = 0;
  	simple_heap_update(pg_class, &tuple->t_self, tuple);
  	CatalogUpdateIndexes(pg_class, tuple);
  
--- 1266,1278 ----
  	RelationOpenSmgr(relation);
  	smgrscheduleunlink(relation->rd_smgr, relation->rd_istemp);
  
! 	/*
! 	 * Update the pg_class row.  The caller is responsible for ensuring the
! 	 * pg_class_nt entry is correct.  While we could update it here, it's just
! 	 * a waste of time to set the values to 0, because currently all callers
! 	 * set them to the correct values sometime after calling us.
! 	 */
  	rd_rel->relfilenode = newrelfilenode;
  	simple_heap_update(pg_class, &tuple->t_self, tuple);
  	CatalogUpdateIndexes(pg_class, tuple);
  
Index: src/backend/commands/analyze.c
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/commands/analyze.c,v
retrieving revision 1.93
diff -c -r1.93 analyze.c
*** src/backend/commands/analyze.c	23 Mar 2006 00:19:28 -0000	1.93
--- src/backend/commands/analyze.c	12 Jun 2006 16:44:32 -0000
***************
*** 159,164 ****
--- 159,174 ----
  	}
  
  	/*
+ 	 * We don't process RELKIND_NON_TRANSACTIONAL relations, but we don't
+ 	 * complain since VACUUM processes them but we don't.
+ 	 */
+ 	if (onerel->rd_rel->relkind == RELKIND_NON_TRANSACTIONAL)
+ 	{
+ 		relation_close(onerel, AccessShareLock);
+ 		return;
+ 	}
+ 
+ 	/*
  	 * Check that it's a plain table; we used to do this in get_rel_oids() but
  	 * seems safer to check after we've locked the relation.
  	 */
***************
*** 422,428 ****
  	 */
  	if (!vacstmt->vacuum)
  	{
! 		vac_update_relstats(RelationGetRelid(onerel),
  							RelationGetNumberOfBlocks(onerel),
  							totalrows,
  							hasindex);
--- 432,438 ----
  	 */
  	if (!vacstmt->vacuum)
  	{
! 		vac_update_relstats(onerel,
  							RelationGetNumberOfBlocks(onerel),
  							totalrows,
  							hasindex);
***************
*** 432,438 ****
  			double		totalindexrows;
  
  			totalindexrows = ceil(thisdata->tupleFract * totalrows);
! 			vac_update_relstats(RelationGetRelid(Irel[ind]),
  								RelationGetNumberOfBlocks(Irel[ind]),
  								totalindexrows,
  								false);
--- 442,448 ----
  			double		totalindexrows;
  
  			totalindexrows = ceil(thisdata->tupleFract * totalrows);
! 			vac_update_relstats(Irel[ind],
  								RelationGetNumberOfBlocks(Irel[ind]),
  								totalindexrows,
  								false);
Index: src/backend/commands/cluster.c
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/commands/cluster.c,v
retrieving revision 1.147
diff -c -r1.147 cluster.c
*** src/backend/commands/cluster.c	2 May 2006 22:25:10 -0000	1.147
--- src/backend/commands/cluster.c	12 Jun 2006 03:48:28 -0000
***************
*** 728,733 ****
--- 728,734 ----
  				relform2;
  	Oid			swaptemp;
  	CatalogIndexState indstate;
+ 	ItemPointerData swap_tid;
  
  	/* We need writable copies of both pg_class tuples. */
  	relRelation = heap_open(RelationRelationId, RowExclusiveLock);
***************
*** 763,781 ****
  
  	/* we should not swap reltoastidxid */
  
! 	/* swap size statistics too, since new rel has freshly-updated stats */
! 	{
! 		int4		swap_pages;
! 		float4		swap_tuples;
! 
! 		swap_pages = relform1->relpages;
! 		relform1->relpages = relform2->relpages;
! 		relform2->relpages = swap_pages;
! 
! 		swap_tuples = relform1->reltuples;
! 		relform1->reltuples = relform2->reltuples;
! 		relform2->reltuples = swap_tuples;
! 	}
  
  	/* Update the tuples in pg_class */
  	simple_heap_update(relRelation, &reltup1->t_self, reltup1);
--- 764,779 ----
  
  	/* we should not swap reltoastidxid */
  
! 	/*
! 	 * Swap pg_class_nt rows too.  This automatically updates the
! 	 * size statistics.
! 	 *
! 	 * XXX make sure this is still correct when adding more rows to
! 	 * pg_class_nt.
! 	 */
! 	swap_tid = relform1->relntrans;
! 	relform1->relntrans = relform2->relntrans;
! 	relform2->relntrans = swap_tid;
  
  	/* Update the tuples in pg_class */
  	simple_heap_update(relRelation, &reltup1->t_self, reltup1);
Index: src/backend/commands/vacuum.c
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/commands/vacuum.c,v
retrieving revision 1.330
diff -c -r1.330 vacuum.c
*** src/backend/commands/vacuum.c	10 May 2006 23:18:39 -0000	1.330
--- src/backend/commands/vacuum.c	12 Jun 2006 04:03:01 -0000
***************
*** 28,35 ****
--- 28,37 ----
  #include "access/subtrans.h"
  #include "access/xlog.h"
  #include "catalog/catalog.h"
+ #include "catalog/heap.h"
  #include "catalog/indexing.h"
  #include "catalog/namespace.h"
+ #include "catalog/pg_class_nt.h"
  #include "catalog/pg_database.h"
  #include "catalog/pg_index.h"
  #include "commands/dbcommands.h"
***************
*** 200,212 ****
  
  /* non-export function prototypes */
  static List *get_rel_oids(List *relids, const RangeVar *vacrel,
! 			 const char *stmttype);
  static void vac_update_dbstats(Oid dbid,
  				   TransactionId vacuumXID,
  				   TransactionId frozenXID);
  static void vac_truncate_clog(TransactionId vacuumXID,
  				  TransactionId frozenXID);
! static bool vacuum_rel(Oid relid, VacuumStmt *vacstmt, char expected_relkind);
  static void full_vacuum_rel(Relation onerel, VacuumStmt *vacstmt);
  static void scan_heap(VRelStats *vacrelstats, Relation onerel,
  		  VacPageList vacuum_pages, VacPageList fraged_pages);
--- 202,214 ----
  
  /* non-export function prototypes */
  static List *get_rel_oids(List *relids, const RangeVar *vacrel,
! 			 const char *stmttype, bool full);
  static void vac_update_dbstats(Oid dbid,
  				   TransactionId vacuumXID,
  				   TransactionId frozenXID);
  static void vac_truncate_clog(TransactionId vacuumXID,
  				  TransactionId frozenXID);
! static bool vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool allow_toast);
  static void full_vacuum_rel(Relation onerel, VacuumStmt *vacstmt);
  static void scan_heap(VRelStats *vacrelstats, Relation onerel,
  		  VacPageList vacuum_pages, VacPageList fraged_pages);
***************
*** 350,356 ****
  	 * Build list of relations to process, unless caller gave us one. (If we
  	 * build one, we put it in vac_context for safekeeping.)
  	 */
! 	relations = get_rel_oids(relids, vacstmt->relation, stmttype);
  
  	if (vacstmt->vacuum && all_rels)
  	{
--- 352,359 ----
  	 * Build list of relations to process, unless caller gave us one. (If we
  	 * build one, we put it in vac_context for safekeeping.)
  	 */
! 	relations = get_rel_oids(relids, vacstmt->relation, stmttype,
! 		   					 vacstmt->full);
  
  	if (vacstmt->vacuum && all_rels)
  	{
***************
*** 446,452 ****
  
  			if (vacstmt->vacuum)
  			{
! 				if (!vacuum_rel(relid, vacstmt, RELKIND_RELATION))
  					all_rels = false;	/* forget about updating dbstats */
  			}
  			if (vacstmt->analyze)
--- 449,455 ----
  
  			if (vacstmt->vacuum)
  			{
! 				if (!vacuum_rel(relid, vacstmt, false))
  					all_rels = false;	/* forget about updating dbstats */
  			}
  			if (vacstmt->analyze)
***************
*** 563,569 ****
   * per-relation transactions.
   */
  static List *
! get_rel_oids(List *relids, const RangeVar *vacrel, const char *stmttype)
  {
  	List	   *oid_list = NIL;
  	MemoryContext oldcontext;
--- 566,573 ----
   * per-relation transactions.
   */
  static List *
! get_rel_oids(List *relids, const RangeVar *vacrel, const char *stmttype,
! 			 bool full)
  {
  	List	   *oid_list = NIL;
  	MemoryContext oldcontext;
***************
*** 590,608 ****
  		Relation	pgclass;
  		HeapScanDesc scan;
  		HeapTuple	tuple;
- 		ScanKeyData key;
- 
- 		ScanKeyInit(&key,
- 					Anum_pg_class_relkind,
- 					BTEqualStrategyNumber, F_CHAREQ,
- 					CharGetDatum(RELKIND_RELATION));
  
  		pgclass = heap_open(RelationRelationId, AccessShareLock);
  
! 		scan = heap_beginscan(pgclass, SnapshotNow, 1, &key);
  
  		while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
  		{
  			/* Make a relation list entry for this guy */
  			oldcontext = MemoryContextSwitchTo(vac_context);
  			oid_list = lappend_oid(oid_list, HeapTupleGetOid(tuple));
--- 594,620 ----
  		Relation	pgclass;
  		HeapScanDesc scan;
  		HeapTuple	tuple;
  
  		pgclass = heap_open(RelationRelationId, AccessShareLock);
  
! 		scan = heap_beginscan(pgclass, SnapshotNow, 0, NULL);
  
  		while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
  		{
+ 			Form_pg_class classForm;
+ 			char		relkind;
+ 
+ 			classForm = (Form_pg_class) GETSTRUCT(tuple);
+ 			relkind = classForm->relkind;
+ 
+ 			/* we only process plain and non-transactional tables */
+ 			if (relkind != RELKIND_RELATION &&
+ 				relkind != RELKIND_NON_TRANSACTIONAL)
+ 				continue;
+ 			/* we only process non-transactional catalogs on lazy vacuum */
+ 			if (relkind == RELKIND_NON_TRANSACTIONAL && full)
+ 				continue;
+ 
  			/* Make a relation list entry for this guy */
  			oldcontext = MemoryContextSwitchTo(vac_context);
  			oid_list = lappend_oid(oid_list, HeapTupleGetOid(tuple));
***************
*** 669,677 ****
   *	vac_update_relstats() -- update statistics for one relation
   *
   *		Update the whole-relation statistics that are kept in its pg_class
!  *		row.  There are additional stats that will be updated if we are
!  *		doing ANALYZE, but we always update these stats.  This routine works
!  *		for both index and heap relation entries in pg_class.
   *
   *		We violate transaction semantics here by overwriting the rel's
   *		existing pg_class tuple with the new values.  This is reasonably
--- 681,689 ----
   *	vac_update_relstats() -- update statistics for one relation
   *
   *		Update the whole-relation statistics that are kept in its pg_class
!  *		and pg_class_nt rows.  There are additional stats that will be updated
!  *		if we are doing ANALYZE, but we always update these stats.  This
!  *		routine works for both index and heap relation entries in pg_class.
   *
   *		We violate transaction semantics here by overwriting the rel's
   *		existing pg_class tuple with the new values.  This is reasonably
***************
*** 679,723 ****
   *		commits.  The reason for this is that if we updated these tuples in
   *		the usual way, vacuuming pg_class itself wouldn't work very well ---
   *		by the time we got done with a vacuum cycle, most of the tuples in
!  *		pg_class would've been obsoleted.  Of course, this only works for
!  *		fixed-size never-null columns, but these are.
   *
   *		This routine is shared by full VACUUM, lazy VACUUM, and stand-alone
   *		ANALYZE.
   */
  void
! vac_update_relstats(Oid relid, BlockNumber num_pages, double num_tuples,
  					bool hasindex)
  {
  	Relation	rd;
  	HeapTuple	ctup;
  	Form_pg_class pgcform;
  	bool		dirty;
  
  	rd = heap_open(RelationRelationId, RowExclusiveLock);
  
  	/* Fetch a copy of the tuple to scribble on */
  	ctup = SearchSysCacheCopy(RELOID,
! 							  ObjectIdGetDatum(relid),
  							  0, 0, 0);
  	if (!HeapTupleIsValid(ctup))
  		elog(ERROR, "pg_class entry for relid %u vanished during vacuuming",
! 			 relid);
  	pgcform = (Form_pg_class) GETSTRUCT(ctup);
  
  	/* Apply required updates, if any, to copied tuple */
  
  	dirty = false;
- 	if (pgcform->relpages != (int32) num_pages)
- 	{
- 		pgcform->relpages = (int32) num_pages;
- 		dirty = true;
- 	}
- 	if (pgcform->reltuples != (float4) num_tuples)
- 	{
- 		pgcform->reltuples = (float4) num_tuples;
- 		dirty = true;
- 	}
  	if (pgcform->relhasindex != hasindex)
  	{
  		pgcform->relhasindex = hasindex;
--- 691,758 ----
   *		commits.  The reason for this is that if we updated these tuples in
   *		the usual way, vacuuming pg_class itself wouldn't work very well ---
   *		by the time we got done with a vacuum cycle, most of the tuples in
!  *		them would've been obsoleted.  Of course, this only works for
!  *		fixed-size never-null columns, but these are.  Also, note this doesn't
!  *		apply to pg_class_nt, because by definition of non-transactional
!  *		catalog we must always update it in-place.
   *
   *		This routine is shared by full VACUUM, lazy VACUUM, and stand-alone
   *		ANALYZE.
   */
  void
! vac_update_relstats(Relation rel, BlockNumber num_pages, double num_tuples,
  					bool hasindex)
  {
  	Relation	rd;
  	HeapTuple	ctup;
+ 	Form_pg_class_nt pgntform;
  	Form_pg_class pgcform;
  	bool		dirty;
  
+ 	/* Process pg_class_nt first */
+ 	rd = heap_open(NtClassRelationId, RowExclusiveLock);
+ 
+ 	/* Fetch a copy of the pg_class_nt tuple to scribble on */
+ 	ctup = get_class_nt_entry(rd, rel);
+ 
+ 	pgntform = (Form_pg_class_nt) GETSTRUCT(ctup);
+ 
+ 	/* Apply required updates, if any, to copied tuple */
+ 
+ 	dirty = false;
+ 	if (pgntform->npages != (int32) num_pages)
+ 	{
+ 		pgntform->npages = (int32) num_pages;
+ 		dirty = true;
+ 	}
+ 	if (pgntform->ntuples != (float4) num_tuples)
+ 	{
+ 		pgntform->ntuples = (float4) num_tuples;
+ 		dirty = true;
+ 	}
+ 
+ 	/* If anything changed, write out the tuple */
+ 	if (dirty)
+ 		update_class_nt_entry(rd, ctup);
+ 	heap_freetuple(ctup);
+ 
+ 	heap_close(rd, RowExclusiveLock);
+ 
+ 	/* Now go for the pg_class tuple */
  	rd = heap_open(RelationRelationId, RowExclusiveLock);
  
  	/* Fetch a copy of the tuple to scribble on */
  	ctup = SearchSysCacheCopy(RELOID,
! 							  ObjectIdGetDatum(RelationGetRelid(rel)),
  							  0, 0, 0);
  	if (!HeapTupleIsValid(ctup))
  		elog(ERROR, "pg_class entry for relid %u vanished during vacuuming",
! 			 RelationGetRelid(rel));
  	pgcform = (Form_pg_class) GETSTRUCT(ctup);
  
  	/* Apply required updates, if any, to copied tuple */
  
  	dirty = false;
  	if (pgcform->relhasindex != hasindex)
  	{
  		pgcform->relhasindex = hasindex;
***************
*** 934,940 ****
   *		At entry and exit, we are not inside a transaction.
   */
  static bool
! vacuum_rel(Oid relid, VacuumStmt *vacstmt, char expected_relkind)
  {
  	LOCKMODE	lmode;
  	Relation	onerel;
--- 969,975 ----
   *		At entry and exit, we are not inside a transaction.
   */
  static bool
! vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool allow_toast)
  {
  	LOCKMODE	lmode;
  	Relation	onerel;
***************
*** 1005,1013 ****
  
  	/*
  	 * Check that it's a plain table; we used to do this in get_rel_oids() but
! 	 * seems safer to check after we've locked the relation.
  	 */
! 	if (onerel->rd_rel->relkind != expected_relkind)
  	{
  		ereport(WARNING,
  				(errmsg("skipping \"%s\" --- cannot vacuum indexes, views, or special system tables",
--- 1040,1051 ----
  
  	/*
  	 * Check that it's a plain table; we used to do this in get_rel_oids() but
! 	 * seems safer to check after we've locked the relation.  We only accept
! 	 * TOAST tables if the caller told us it's OK to do so.
  	 */
! 	if (!(onerel->rd_rel->relkind == RELKIND_RELATION ||
! 		  onerel->rd_rel->relkind == RELKIND_NON_TRANSACTIONAL ||
! 		  (onerel->rd_rel->relkind == RELKIND_TOASTVALUE && allow_toast)))
  	{
  		ereport(WARNING,
  				(errmsg("skipping \"%s\" --- cannot vacuum indexes, views, or special system tables",
***************
*** 1019,1024 ****
--- 1057,1078 ----
  	}
  
  	/*
+ 	 * We only process non-transactional catalogs in lazy vacuum, because they
+ 	 * are referenced by TID and applying VACUUM FULL to them would destroy the
+ 	 * references.
+ 	 */
+ 	if (onerel->rd_rel->relkind == RELKIND_NON_TRANSACTIONAL && vacstmt->full)
+ 	{
+ 		ereport(WARNING,
+ 				(errmsg("skipping \"%s\" --- cannot vacuum non-transactional catalogs in VACUUM FULL",
+ 						RelationGetRelationName(onerel))));
+ 		relation_close(onerel, lmode);
+ 		StrategyHintVacuum(false);
+ 		CommitTransactionCommand();
+ 		return false;
+ 	}
+ 
+ 	/*
  	 * Silently ignore tables that are temp tables of other backends ---
  	 * trying to vacuum these will lead to great unhappiness, since their
  	 * contents are probably not up-to-date on disk.  (We don't throw a
***************
*** 1079,1085 ****
  	 */
  	if (toast_relid != InvalidOid)
  	{
! 		if (!vacuum_rel(toast_relid, vacstmt, RELKIND_TOASTVALUE))
  			result = false;		/* failed to vacuum the TOAST table? */
  	}
  
--- 1133,1139 ----
  	 */
  	if (toast_relid != InvalidOid)
  	{
! 		if (!vacuum_rel(toast_relid, vacstmt, true))
  			result = false;		/* failed to vacuum the TOAST table? */
  	}
  
***************
*** 1179,1185 ****
  	vac_update_fsm(onerel, &fraged_pages, vacrelstats->rel_pages);
  
  	/* update statistics in pg_class */
! 	vac_update_relstats(RelationGetRelid(onerel), vacrelstats->rel_pages,
  						vacrelstats->rel_tuples, vacrelstats->hasindex);
  
  	/* report results to the stats collector, too */
--- 1233,1239 ----
  	vac_update_fsm(onerel, &fraged_pages, vacrelstats->rel_pages);
  
  	/* update statistics in pg_class */
! 	vac_update_relstats(onerel, vacrelstats->rel_pages,
  						vacrelstats->rel_tuples, vacrelstats->hasindex);
  
  	/* report results to the stats collector, too */
***************
*** 2938,2944 ****
  		return;
  
  	/* now update statistics in pg_class */
! 	vac_update_relstats(RelationGetRelid(indrel),
  						stats->num_pages, stats->num_index_tuples,
  						false);
  
--- 2992,2998 ----
  		return;
  
  	/* now update statistics in pg_class */
! 	vac_update_relstats(indrel,
  						stats->num_pages, stats->num_index_tuples,
  						false);
  
***************
*** 3007,3013 ****
  		return;
  
  	/* now update statistics in pg_class */
! 	vac_update_relstats(RelationGetRelid(indrel),
  						stats->num_pages, stats->num_index_tuples,
  						false);
  
--- 3061,3067 ----
  		return;
  
  	/* now update statistics in pg_class */
! 	vac_update_relstats(indrel,
  						stats->num_pages, stats->num_index_tuples,
  						false);
  
Index: src/backend/commands/vacuumlazy.c
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/commands/vacuumlazy.c,v
retrieving revision 1.70
diff -c -r1.70 vacuumlazy.c
*** src/backend/commands/vacuumlazy.c	2 May 2006 22:25:10 -0000	1.70
--- src/backend/commands/vacuumlazy.c	10 Jun 2006 23:17:47 -0000
***************
*** 175,181 ****
  	lazy_update_fsm(onerel, vacrelstats);
  
  	/* Update statistics in pg_class */
! 	vac_update_relstats(RelationGetRelid(onerel),
  						vacrelstats->rel_pages,
  						vacrelstats->rel_tuples,
  						hasindex);
--- 175,181 ----
  	lazy_update_fsm(onerel, vacrelstats);
  
  	/* Update statistics in pg_class */
! 	vac_update_relstats(onerel,
  						vacrelstats->rel_pages,
  						vacrelstats->rel_tuples,
  						hasindex);
***************
*** 667,673 ****
  		return;
  
  	/* now update statistics in pg_class */
! 	vac_update_relstats(RelationGetRelid(indrel),
  						stats->num_pages,
  						stats->num_index_tuples,
  						false);
--- 667,673 ----
  		return;
  
  	/* now update statistics in pg_class */
! 	vac_update_relstats(indrel,
  						stats->num_pages,
  						stats->num_index_tuples,
  						false);
Index: src/backend/optimizer/util/plancat.c
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/optimizer/util/plancat.c,v
retrieving revision 1.119
diff -c -r1.119 plancat.c
*** src/backend/optimizer/util/plancat.c	5 Mar 2006 15:58:31 -0000	1.119
--- src/backend/optimizer/util/plancat.c	10 Jun 2006 23:17:47 -0000
***************
*** 19,24 ****
--- 19,25 ----
  
  #include "access/genam.h"
  #include "access/heapam.h"
+ #include "catalog/heap.h"
  #include "catalog/pg_amop.h"
  #include "catalog/pg_inherits.h"
  #include "catalog/pg_index.h"
***************
*** 235,240 ****
--- 236,243 ----
  	BlockNumber relpages;
  	double		reltuples;
  	double		density;
+ 	int4		npages;
+ 	float4		ntuples;
  
  	switch (rel->rd_rel->relkind)
  	{
***************
*** 263,269 ****
  			 * world, and it shouldn't degrade the quality of the plan too
  			 * much anyway to err in this direction.
  			 */
! 			if (curpages < 10 && rel->rd_rel->relpages == 0)
  				curpages = 10;
  
  			/* report estimated # pages */
--- 266,273 ----
  			 * world, and it shouldn't degrade the quality of the plan too
  			 * much anyway to err in this direction.
  			 */
! 			relation_get_ntups_npages(rel, &ntuples, &npages);
! 			if (curpages < 10 && ntuples == 0)
  				curpages = 10;
  
  			/* report estimated # pages */
***************
*** 275,282 ****
  				break;
  			}
  			/* coerce values in pg_class to more desirable types */
! 			relpages = (BlockNumber) rel->rd_rel->relpages;
! 			reltuples = (double) rel->rd_rel->reltuples;
  
  			/*
  			 * If it's an index, discount the metapage.  This is a kluge
--- 279,286 ----
  				break;
  			}
  			/* coerce values in pg_class to more desirable types */
! 			relpages = (BlockNumber) npages;
! 			reltuples = (double) ntuples;
  
  			/*
  			 * If it's an index, discount the metapage.  This is a kluge
Index: src/backend/postmaster/autovacuum.c
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/postmaster/autovacuum.c,v
retrieving revision 1.19
diff -c -r1.19 autovacuum.c
*** src/backend/postmaster/autovacuum.c	19 May 2006 15:15:37 -0000	1.19
--- src/backend/postmaster/autovacuum.c	12 Jun 2006 03:51:26 -0000
***************
*** 24,29 ****
--- 24,30 ----
  #include "access/genam.h"
  #include "access/heapam.h"
  #include "access/xlog.h"
+ #include "catalog/heap.h"
  #include "catalog/indexing.h"
  #include "catalog/namespace.h"
  #include "catalog/pg_autovacuum.h"
***************
*** 615,623 ****
  		ScanKeyData entry[1];
  		Oid			relid;
  
! 		/* Consider only regular and toast tables. */
  		if (classForm->relkind != RELKIND_RELATION &&
! 			classForm->relkind != RELKIND_TOASTVALUE)
  			continue;
  
  		/*
--- 616,625 ----
  		ScanKeyData entry[1];
  		Oid			relid;
  
! 		/* Consider only regular, non-transactional and toast tables. */
  		if (classForm->relkind != RELKIND_RELATION &&
! 			classForm->relkind != RELKIND_TOASTVALUE &&
! 			classForm->relkind != RELKIND_NON_TRANSACTIONAL)
  			continue;
  
  		/*
***************
*** 734,740 ****
  					 List **toast_table_ids)
  {
  	Relation	rel;
! 	float4		reltuples;		/* pg_class.reltuples */
  
  	/* constants from pg_autovacuum or GUC variables */
  	int			vac_base_thresh,
--- 736,742 ----
  					 List **toast_table_ids)
  {
  	Relation	rel;
! 	float4		reltuples;		/* pg_class_nt.ntuples */
  
  	/* constants from pg_autovacuum or GUC variables */
  	int			vac_base_thresh,
***************
*** 773,779 ****
  	if (!PointerIsValid(rel))
  		return;
  
! 	reltuples = rel->rd_rel->reltuples;
  	vactuples = tabentry->n_dead_tuples;
  	anltuples = tabentry->n_live_tuples + tabentry->n_dead_tuples -
  		tabentry->last_anl_tuples;
--- 775,781 ----
  	if (!PointerIsValid(rel))
  		return;
  
! 	relation_get_ntups_npages(rel, &reltuples, NULL);
  	vactuples = tabentry->n_dead_tuples;
  	anltuples = tabentry->n_live_tuples + tabentry->n_dead_tuples -
  		tabentry->last_anl_tuples;
***************
*** 843,849 ****
  
  	Assert(CurrentMemoryContext == AutovacMemCxt);
  
! 	if (classForm->relkind == RELKIND_RELATION)
  	{
  		if (dovacuum || doanalyze)
  			elog(DEBUG2, "autovac: will%s%s %s",
--- 845,852 ----
  
  	Assert(CurrentMemoryContext == AutovacMemCxt);
  
! 	if (classForm->relkind == RELKIND_RELATION ||
! 		classForm->relkind == RELKIND_NON_TRANSACTIONAL)
  	{
  		if (dovacuum || doanalyze)
  			elog(DEBUG2, "autovac: will%s%s %s",
Index: src/backend/utils/cache/relcache.c
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/utils/cache/relcache.c,v
retrieving revision 1.241
diff -c -r1.241 relcache.c
*** src/backend/utils/cache/relcache.c	6 May 2006 15:51:07 -0000	1.241
--- src/backend/utils/cache/relcache.c	12 Jun 2006 17:01:20 -0000
***************
*** 40,45 ****
--- 40,46 ----
  #include "catalog/pg_attrdef.h"
  #include "catalog/pg_attribute.h"
  #include "catalog/pg_authid.h"
+ #include "catalog/pg_class_nt.h"
  #include "catalog/pg_constraint.h"
  #include "catalog/pg_index.h"
  #include "catalog/pg_namespace.h"
***************
*** 71,77 ****
   */
  #define RELCACHE_INIT_FILENAME	"pg_internal.init"
  
! #define RELCACHE_INIT_FILEMAGIC		0x573262	/* version ID value */
  
  /*
   *		hardcoded tuple descriptors.  see include/catalog/pg_attribute.h
--- 72,78 ----
   */
  #define RELCACHE_INIT_FILENAME	"pg_internal.init"
  
! #define RELCACHE_INIT_FILEMAGIC		0x573263	/* version ID value */
  
  /*
   *		hardcoded tuple descriptors.  see include/catalog/pg_attribute.h
***************
*** 81,86 ****
--- 82,88 ----
  static FormData_pg_attribute Desc_pg_proc[Natts_pg_proc] = {Schema_pg_proc};
  static FormData_pg_attribute Desc_pg_type[Natts_pg_type] = {Schema_pg_type};
  static FormData_pg_attribute Desc_pg_index[Natts_pg_index] = {Schema_pg_index};
+ static FormData_pg_attribute Desc_pg_class_nt[Natts_pg_class_nt] = {Schema_pg_class_nt};
  
  /*
   *		Hash tables that index the relation cache
***************
*** 1163,1169 ****
   *		catalogs.
   *
   * formrdesc is currently used for: pg_class, pg_attribute, pg_proc,
!  * and pg_type (see RelationCacheInitializePhase2).
   *
   * Note that these catalogs can't have constraints (except attnotnull),
   * default values, rules, or triggers, since we don't cope with any of that.
--- 1165,1171 ----
   *		catalogs.
   *
   * formrdesc is currently used for: pg_class, pg_attribute, pg_proc,
!  * pg_class_nt and pg_type (see RelationCacheInitializePhase2).
   *
   * Note that these catalogs can't have constraints (except attnotnull),
   * default values, rules, or triggers, since we don't cope with any of that.
***************
*** 1220,1232 ****
  	 */
  	relation->rd_rel->relisshared = false;
  
- 	relation->rd_rel->relpages = 1;
- 	relation->rd_rel->reltuples = 1;
  	relation->rd_rel->relkind = RELKIND_RELATION;
  	relation->rd_rel->relhasoids = hasoids;
  	relation->rd_rel->relnatts = (int16) natts;
  
  	/*
  	 * initialize attribute tuple form
  	 *
  	 * Unlike the case with the relation tuple, this data had better be right
--- 1222,1238 ----
  	 */
  	relation->rd_rel->relisshared = false;
  
  	relation->rd_rel->relkind = RELKIND_RELATION;
  	relation->rd_rel->relhasoids = hasoids;
  	relation->rd_rel->relnatts = (int16) natts;
  
  	/*
+ 	 * We don't need relntrans at this point, so set it to invalid to make
+ 	 * sure we will correct it later before trying to access it.
+ 	 */
+ 	ItemPointerSetInvalid(&(relation->rd_rel->relntrans));
+ 
+ 	/*
  	 * initialize attribute tuple form
  	 *
  	 * Unlike the case with the relation tuple, this data had better be right
***************
*** 2028,2033 ****
--- 2034,2040 ----
  		case AttributeRelationId:
  		case ProcedureRelationId:
  		case TypeRelationId:
+ 		case NtClassRelationId:
  			nailit = true;
  			break;
  		default:
***************
*** 2120,2125 ****
--- 2127,2146 ----
  	rel->rd_rel->relfilenode = relid;
  	rel->rd_rel->reltablespace = reltablespace;
  
+ 	/*
+ 	 * Set relntrans to invalid for now.  It'll be corrected later by the
+ 	 * caller.  However, in bootstrap mode we must create valid entries for
+ 	 * bootstrap relations, because the bootstrap process creates those only
+ 	 * with heap_create and cannot fix them later, because it doesn't have
+ 	 * access to their true pg_class_nt TID.  So we make them point to the
+ 	 * dummy entry (0,1) to make sure the bootstrapper doesn't overwrite other
+ 	 * relation's entry.
+ 	 */
+ 	if (IsBootstrapProcessingMode() && nailit)
+ 		ItemPointerSet(&(rel->rd_rel->relntrans), 0, 1);
+ 	else
+ 		ItemPointerSetInvalid(&(rel->rd_rel->relntrans));
+ 
  	RelationInitLockInfo(rel);	/* see lmgr.c */
  
  	RelationInitPhysicalAddr(rel);
***************
*** 2230,2237 ****
  				  true, Natts_pg_proc, Desc_pg_proc);
  		formrdesc("pg_type", PG_TYPE_RELTYPE_OID,
  				  true, Natts_pg_type, Desc_pg_type);
  
! #define NUM_CRITICAL_RELS	4	/* fix if you change list above */
  	}
  
  	MemoryContextSwitchTo(oldcxt);
--- 2251,2260 ----
  				  true, Natts_pg_proc, Desc_pg_proc);
  		formrdesc("pg_type", PG_TYPE_RELTYPE_OID,
  				  true, Natts_pg_type, Desc_pg_type);
+ 		formrdesc("pg_class_nt", PG_CLASS_NT_RELTYPE_OID,
+ 				  true, Natts_pg_class_nt, Desc_pg_class_nt);
  
! #define NUM_CRITICAL_RELS	5	/* fix if you change list above */
  	}
  
  	MemoryContextSwitchTo(oldcxt);
Index: src/include/catalog/catversion.h
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/include/catalog/catversion.h,v
retrieving revision 1.334
diff -c -r1.334 catversion.h
*** src/include/catalog/catversion.h	24 May 2006 11:01:39 -0000	1.334
--- src/include/catalog/catversion.h	12 Jun 2006 03:33:27 -0000
***************
*** 53,58 ****
   */
  
  /*							yyyymmddN */
! #define CATALOG_VERSION_NO	200605241
  
  #endif
--- 53,58 ----
   */
  
  /*							yyyymmddN */
! #define CATALOG_VERSION_NO	200606101
  
  #endif
Index: src/include/catalog/heap.h
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/include/catalog/heap.h,v
retrieving revision 1.80
diff -c -r1.80 heap.h
*** src/include/catalog/heap.h	30 Apr 2006 01:08:07 -0000	1.80
--- src/include/catalog/heap.h	12 Jun 2006 03:39:27 -0000
***************
*** 43,48 ****
--- 43,50 ----
  			bool shared_relation,
  			bool allow_system_table_mods);
  
+ extern ItemPointerData AddNewNtClassTuple(Relation new_rel_desc, char relkind);
+ 
  extern Oid heap_create_with_catalog(const char *relname,
  						 Oid relnamespace,
  						 Oid reltablespace,
***************
*** 86,91 ****
--- 88,94 ----
  				  DropBehavior behavior, bool complain);
  extern void RemoveAttrDefaultById(Oid attrdefId);
  extern void RemoveStatistics(Oid relid, AttrNumber attnum);
+ extern void DeleteNtClassTuple(ItemPointer tid);
  
  extern Form_pg_attribute SystemAttributeDefinition(AttrNumber attno,
  						  bool relhasoids);
***************
*** 97,100 ****
--- 100,114 ----
  
  extern void CheckAttributeType(const char *attname, Oid atttypid);
  
+ /*
+  * use "struct HeapTupleData *" here instead of HeapTuple to avoid including
+  * htup.h
+  */
+ extern void relation_get_ntups_npages(Relation relation, float4 *ntuples,
+ 						  int4 *npages);
+ extern struct HeapTupleData *get_class_nt_entry(Relation pg_class_nt,
+ 				   Relation target);
+ extern void update_class_nt_entry(Relation pg_class_nt,
+ 					  struct HeapTupleData *tuple);
+ 
  #endif   /* HEAP_H */
Index: src/include/catalog/pg_attribute.h
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/include/catalog/pg_attribute.h,v
retrieving revision 1.120
diff -c -r1.120 pg_attribute.h
*** src/include/catalog/pg_attribute.h	5 Mar 2006 15:58:54 -0000	1.120
--- src/include/catalog/pg_attribute.h	12 Jun 2006 03:39:45 -0000
***************
*** 387,410 ****
  { 1259, {"relam"},		   26, -1,	4,	5, 0, -1, -1, true, 'p', 'i', true, false, false, true, 0 }, \
  { 1259, {"relfilenode"},   26, -1,	4,	6, 0, -1, -1, true, 'p', 'i', true, false, false, true, 0 }, \
  { 1259, {"reltablespace"}, 26, -1,	4,	7, 0, -1, -1, true, 'p', 'i', true, false, false, true, 0 }, \
! { 1259, {"relpages"},	   23, -1,	4,	8, 0, -1, -1, true, 'p', 'i', true, false, false, true, 0 }, \
! { 1259, {"reltuples"},	   700, -1, 4,	9, 0, -1, -1, false, 'p', 'i', true, false, false, true, 0 }, \
! { 1259, {"reltoastrelid"}, 26, -1,	4, 10, 0, -1, -1, true, 'p', 'i', true, false, false, true, 0 }, \
! { 1259, {"reltoastidxid"}, 26, -1,	4, 11, 0, -1, -1, true, 'p', 'i', true, false, false, true, 0 }, \
! { 1259, {"relhasindex"},   16, -1,	1, 12, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
! { 1259, {"relisshared"},   16, -1,	1, 13, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
! { 1259, {"relkind"},	   18, -1,	1, 14, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
! { 1259, {"relnatts"},	   21, -1,	2, 15, 0, -1, -1, true, 'p', 's', true, false, false, true, 0 }, \
! { 1259, {"relchecks"},	   21, -1,	2, 16, 0, -1, -1, true, 'p', 's', true, false, false, true, 0 }, \
! { 1259, {"reltriggers"},   21, -1,	2, 17, 0, -1, -1, true, 'p', 's', true, false, false, true, 0 }, \
! { 1259, {"relukeys"},	   21, -1,	2, 18, 0, -1, -1, true, 'p', 's', true, false, false, true, 0 }, \
! { 1259, {"relfkeys"},	   21, -1,	2, 19, 0, -1, -1, true, 'p', 's', true, false, false, true, 0 }, \
! { 1259, {"relrefs"},	   21, -1,	2, 20, 0, -1, -1, true, 'p', 's', true, false, false, true, 0 }, \
! { 1259, {"relhasoids"},    16, -1,	1, 21, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
! { 1259, {"relhaspkey"},    16, -1,	1, 22, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
! { 1259, {"relhasrules"},   16, -1,	1, 23, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
! { 1259, {"relhassubclass"},16, -1,	1, 24, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
! { 1259, {"relacl"},		 1034, -1, -1, 25, 1, -1, -1, false, 'x', 'i', false, false, false, true, 0 }
  
  DATA(insert ( 1259 relname			19 -1 NAMEDATALEN	1 0 -1 -1 f p i t f f t 0));
  DATA(insert ( 1259 relnamespace		26 -1 4   2 0 -1 -1 t p i t f f t 0));
--- 387,409 ----
  { 1259, {"relam"},		   26, -1,	4,	5, 0, -1, -1, true, 'p', 'i', true, false, false, true, 0 }, \
  { 1259, {"relfilenode"},   26, -1,	4,	6, 0, -1, -1, true, 'p', 'i', true, false, false, true, 0 }, \
  { 1259, {"reltablespace"}, 26, -1,	4,	7, 0, -1, -1, true, 'p', 'i', true, false, false, true, 0 }, \
! { 1259, {"reltoastrelid"}, 26, -1,	4, 8, 0, -1, -1, true, 'p', 'i', true, false, false, true, 0 }, \
! { 1259, {"reltoastidxid"}, 26, -1,	4, 9, 0, -1, -1, true, 'p', 'i', true, false, false, true, 0 }, \
! { 1259, {"relntrans"},	   27, -1,	6, 10, 0, -1, -1, false, 'p', 's', true, false, false, true, 0 }, \
! { 1259, {"relhasindex"},   16, -1,	1, 11, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
! { 1259, {"relisshared"},   16, -1,	1, 12, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
! { 1259, {"relkind"},	   18, -1,	1, 13, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
! { 1259, {"relnatts"},	   21, -1,	2, 14, 0, -1, -1, true, 'p', 's', true, false, false, true, 0 }, \
! { 1259, {"relchecks"},	   21, -1,	2, 15, 0, -1, -1, true, 'p', 's', true, false, false, true, 0 }, \
! { 1259, {"reltriggers"},   21, -1,	2, 16, 0, -1, -1, true, 'p', 's', true, false, false, true, 0 }, \
! { 1259, {"relukeys"},	   21, -1,	2, 17, 0, -1, -1, true, 'p', 's', true, false, false, true, 0 }, \
! { 1259, {"relfkeys"},	   21, -1,	2, 18, 0, -1, -1, true, 'p', 's', true, false, false, true, 0 }, \
! { 1259, {"relrefs"},	   21, -1,	2, 19, 0, -1, -1, true, 'p', 's', true, false, false, true, 0 }, \
! { 1259, {"relhasoids"},    16, -1,	1, 20, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
! { 1259, {"relhaspkey"},    16, -1,	1, 21, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
! { 1259, {"relhasrules"},   16, -1,	1, 22, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
! { 1259, {"relhassubclass"},16, -1,	1, 23, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
! { 1259, {"relacl"},		 1034, -1, -1, 24, 1, -1, -1, false, 'x', 'i', false, false, false, true, 0 }
  
  DATA(insert ( 1259 relname			19 -1 NAMEDATALEN	1 0 -1 -1 f p i t f f t 0));
  DATA(insert ( 1259 relnamespace		26 -1 4   2 0 -1 -1 t p i t f f t 0));
***************
*** 413,436 ****
  DATA(insert ( 1259 relam			26 -1 4   5 0 -1 -1 t p i t f f t 0));
  DATA(insert ( 1259 relfilenode		26 -1 4   6 0 -1 -1 t p i t f f t 0));
  DATA(insert ( 1259 reltablespace	26 -1 4   7 0 -1 -1 t p i t f f t 0));
! DATA(insert ( 1259 relpages			23 -1 4   8 0 -1 -1 t p i t f f t 0));
! DATA(insert ( 1259 reltuples	   700 -1 4   9 0 -1 -1 f p i t f f t 0));
! DATA(insert ( 1259 reltoastrelid	26 -1 4  10 0 -1 -1 t p i t f f t 0));
! DATA(insert ( 1259 reltoastidxid	26 -1 4  11 0 -1 -1 t p i t f f t 0));
! DATA(insert ( 1259 relhasindex		16 -1 1  12 0 -1 -1 t p c t f f t 0));
! DATA(insert ( 1259 relisshared		16 -1 1  13 0 -1 -1 t p c t f f t 0));
! DATA(insert ( 1259 relkind			18 -1 1  14 0 -1 -1 t p c t f f t 0));
! DATA(insert ( 1259 relnatts			21 -1 2  15 0 -1 -1 t p s t f f t 0));
! DATA(insert ( 1259 relchecks		21 -1 2  16 0 -1 -1 t p s t f f t 0));
! DATA(insert ( 1259 reltriggers		21 -1 2  17 0 -1 -1 t p s t f f t 0));
! DATA(insert ( 1259 relukeys			21 -1 2  18 0 -1 -1 t p s t f f t 0));
! DATA(insert ( 1259 relfkeys			21 -1 2  19 0 -1 -1 t p s t f f t 0));
! DATA(insert ( 1259 relrefs			21 -1 2  20 0 -1 -1 t p s t f f t 0));
! DATA(insert ( 1259 relhasoids		16 -1 1  21 0 -1 -1 t p c t f f t 0));
! DATA(insert ( 1259 relhaspkey		16 -1 1  22 0 -1 -1 t p c t f f t 0));
! DATA(insert ( 1259 relhasrules		16 -1 1  23 0 -1 -1 t p c t f f t 0));
! DATA(insert ( 1259 relhassubclass	16 -1 1  24 0 -1 -1 t p c t f f t 0));
! DATA(insert ( 1259 relacl		  1034 -1 -1 25 1 -1 -1 f x i f f f t 0));
  DATA(insert ( 1259 ctid				27 0  6  -1 0 -1 -1 f p s t f f t 0));
  DATA(insert ( 1259 oid				26 0  4  -2 0 -1 -1 t p i t f f t 0));
  DATA(insert ( 1259 xmin				28 0  4  -3 0 -1 -1 t p i t f f t 0));
--- 412,434 ----
  DATA(insert ( 1259 relam			26 -1 4   5 0 -1 -1 t p i t f f t 0));
  DATA(insert ( 1259 relfilenode		26 -1 4   6 0 -1 -1 t p i t f f t 0));
  DATA(insert ( 1259 reltablespace	26 -1 4   7 0 -1 -1 t p i t f f t 0));
! DATA(insert ( 1259 reltoastrelid	26 -1 4  8 0 -1 -1 t p i t f f t 0));
! DATA(insert ( 1259 reltoastidxid	26 -1 4  9 0 -1 -1 t p i t f f t 0));
! DATA(insert ( 1259 relntrans		27 -1 6  10 0 -1 -1 f p s t f f t 0));
! DATA(insert ( 1259 relhasindex		16 -1 1  11 0 -1 -1 t p c t f f t 0));
! DATA(insert ( 1259 relisshared		16 -1 1  12 0 -1 -1 t p c t f f t 0));
! DATA(insert ( 1259 relkind			18 -1 1  13 0 -1 -1 t p c t f f t 0));
! DATA(insert ( 1259 relnatts			21 -1 2  14 0 -1 -1 t p s t f f t 0));
! DATA(insert ( 1259 relchecks		21 -1 2  15 0 -1 -1 t p s t f f t 0));
! DATA(insert ( 1259 reltriggers		21 -1 2  16 0 -1 -1 t p s t f f t 0));
! DATA(insert ( 1259 relukeys			21 -1 2  17 0 -1 -1 t p s t f f t 0));
! DATA(insert ( 1259 relfkeys			21 -1 2  18 0 -1 -1 t p s t f f t 0));
! DATA(insert ( 1259 relrefs			21 -1 2  19 0 -1 -1 t p s t f f t 0));
! DATA(insert ( 1259 relhasoids		16 -1 1  20 0 -1 -1 t p c t f f t 0));
! DATA(insert ( 1259 relhaspkey		16 -1 1  21 0 -1 -1 t p c t f f t 0));
! DATA(insert ( 1259 relhasrules		16 -1 1  22 0 -1 -1 t p c t f f t 0));
! DATA(insert ( 1259 relhassubclass	16 -1 1  23 0 -1 -1 t p c t f f t 0));
! DATA(insert ( 1259 relacl		  1034 -1 -1 24 1 -1 -1 f x i f f f t 0));
  DATA(insert ( 1259 ctid				27 0  6  -1 0 -1 -1 f p s t f f t 0));
  DATA(insert ( 1259 oid				26 0  4  -2 0 -1 -1 t p i t f f t 0));
  DATA(insert ( 1259 xmin				28 0  4  -3 0 -1 -1 t p i t f f t 0));
***************
*** 440,445 ****
--- 438,461 ----
  DATA(insert ( 1259 tableoid			26 0  4  -7 0 -1 -1 t p i t f f t 0));
  
  /* ----------------
+  *		pg_class_nt
+  * ----------------
+  */
+ #define Schema_pg_class_nt \
+ { 1004, {"npages"},	   23, -1,	4,	1, 0, -1, -1, true, 'p', 'i', true, false, false, true, 0 }, \
+ { 1004, {"ntuples"},	   700, -1, 4,	2, 0, -1, -1, false, 'p', 'i', true, false, false, true, 0 }
+ 
+ DATA(insert ( 1004 npages		 23 -1 4  1 0 -1 -1 t p i t f f t 0));
+ DATA(insert ( 1004 ntuples	   	700 -1 4  2 0 -1 -1 f p i t f f t 0));
+ DATA(insert ( 1004 ctid			 27  0 6 -1 0 -1 -1 f p s t f f t 0));
+ /* no OIDs in pg_class_nt */
+ DATA(insert ( 1004 xmin			 28  0 4 -3 0 -1 -1 t p i t f f t 0));
+ DATA(insert ( 1004 cmin			 29  0 4 -4 0 -1 -1 t p i t f f t 0));
+ DATA(insert ( 1004 xmax			 28  0 4 -5 0 -1 -1 t p i t f f t 0));
+ DATA(insert ( 1004 cmax			 29  0 4 -6 0 -1 -1 t p i t f f t 0));
+ DATA(insert ( 1004 tableoid		 26  0 4 -7 0 -1 -1 t p i t f f t 0));
+ 
+ /* ----------------
   *		pg_index
   *
   * pg_index is not bootstrapped in the same way as the other relations that
Index: src/include/catalog/pg_class.h
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/include/catalog/pg_class.h,v
retrieving revision 1.92
diff -c -r1.92 pg_class.h
*** src/include/catalog/pg_class.h	28 May 2006 02:27:08 -0000	1.92
--- src/include/catalog/pg_class.h	12 Jun 2006 16:11:40 -0000
***************
*** 19,24 ****
--- 19,26 ----
  #ifndef PG_CLASS_H
  #define PG_CLASS_H
  
+ #include "storage/itemptr.h"
+ 
  /* ----------------
   *		postgres.h contains the system type definitions and the
   *		CATALOG(), BKI_BOOTSTRAP and DATA() sugar words so this file
***************
*** 42,47 ****
--- 44,59 ----
   */
  #define RelationRelationId	1259
  
+ /*
+  * This CATALOG() entry is used by genbki to create the initial bootstrap file,
+  * but the bootstrap type system only recognizes "tid" as a valid type.
+  * However, CPP also turns this definition into a C struct, but the C name of
+  * that type is actually ItemPointerData.  So we put this definition here in
+  * order to have both systems understand that element.  To limit the possible
+  * damage done, we #undef it right at the bottom.
+  */
+ #define tid	ItemPointerData
+ 
  CATALOG(pg_class,1259) BKI_BOOTSTRAP
  {
  	NameData	relname;		/* class name */
***************
*** 51,60 ****
  	Oid			relam;			/* index access method; 0 if not an index */
  	Oid			relfilenode;	/* identifier of physical storage file */
  	Oid			reltablespace;	/* identifier of table space for relation */
- 	int4		relpages;		/* # of blocks (not always up-to-date) */
- 	float4		reltuples;		/* # of tuples (not always up-to-date) */
  	Oid			reltoastrelid;	/* OID of toast table; 0 if none */
  	Oid			reltoastidxid;	/* if toast table, OID of chunk_id index */
  	bool		relhasindex;	/* T if has (or has had) any indexes */
  	bool		relisshared;	/* T if shared across databases */
  	char		relkind;		/* see RELKIND_xxx constants below */
--- 63,71 ----
  	Oid			relam;			/* index access method; 0 if not an index */
  	Oid			relfilenode;	/* identifier of physical storage file */
  	Oid			reltablespace;	/* identifier of table space for relation */
  	Oid			reltoastrelid;	/* OID of toast table; 0 if none */
  	Oid			reltoastidxid;	/* if toast table, OID of chunk_id index */
+ 	tid			relntrans;		/* CTID of pg_class_nt entry */
  	bool		relhasindex;	/* T if has (or has had) any indexes */
  	bool		relisshared;	/* T if shared across databases */
  	char		relkind;		/* see RELKIND_xxx constants below */
***************
*** 80,85 ****
--- 91,97 ----
  	 */
  	aclitem		relacl[1];		/* we declare this just for the catalog */
  } FormData_pg_class;
+ #undef tid
  
  /* Size of fixed part of pg_class tuples, not counting relacl or padding */
  #define CLASS_TUPLE_SIZE \
***************
*** 103,110 ****
   *		relacl field.  This is a kluge.
   * ----------------
   */
! #define Natts_pg_class_fixed			24
! #define Natts_pg_class					25
  #define Anum_pg_class_relname			1
  #define Anum_pg_class_relnamespace		2
  #define Anum_pg_class_reltype			3
--- 115,122 ----
   *		relacl field.  This is a kluge.
   * ----------------
   */
! #define Natts_pg_class_fixed			23
! #define Natts_pg_class					24
  #define Anum_pg_class_relname			1
  #define Anum_pg_class_relnamespace		2
  #define Anum_pg_class_reltype			3
***************
*** 112,135 ****
  #define Anum_pg_class_relam				5
  #define Anum_pg_class_relfilenode		6
  #define Anum_pg_class_reltablespace		7
! #define Anum_pg_class_relpages			8
! #define Anum_pg_class_reltuples			9
! #define Anum_pg_class_reltoastrelid		10
! #define Anum_pg_class_reltoastidxid		11
! #define Anum_pg_class_relhasindex		12
! #define Anum_pg_class_relisshared		13
! #define Anum_pg_class_relkind			14
! #define Anum_pg_class_relnatts			15
! #define Anum_pg_class_relchecks			16
! #define Anum_pg_class_reltriggers		17
! #define Anum_pg_class_relukeys			18
! #define Anum_pg_class_relfkeys			19
! #define Anum_pg_class_relrefs			20
! #define Anum_pg_class_relhasoids		21
! #define Anum_pg_class_relhaspkey		22
! #define Anum_pg_class_relhasrules		23
! #define Anum_pg_class_relhassubclass	24
! #define Anum_pg_class_relacl			25
  
  /* ----------------
   *		initial contents of pg_class
--- 124,146 ----
  #define Anum_pg_class_relam				5
  #define Anum_pg_class_relfilenode		6
  #define Anum_pg_class_reltablespace		7
! #define Anum_pg_class_reltoastrelid		8
! #define Anum_pg_class_reltoastidxid		9
! #define Anum_pg_class_relhasindex		10
! #define Anum_pg_class_relisshared		11
! #define Anum_pg_class_relkind			12
! #define Anum_pg_class_relnatts			13
! #define Anum_pg_class_relntrans			14
! #define Anum_pg_class_relchecks			15
! #define Anum_pg_class_reltriggers		16
! #define Anum_pg_class_relukeys			17
! #define Anum_pg_class_relfkeys			18
! #define Anum_pg_class_relrefs			19
! #define Anum_pg_class_relhasoids		20
! #define Anum_pg_class_relhaspkey		21
! #define Anum_pg_class_relhasrules		22
! #define Anum_pg_class_relhassubclass	23
! #define Anum_pg_class_relacl			24
  
  /* ----------------
   *		initial contents of pg_class
***************
*** 139,151 ****
   * ----------------
   */
  
! DATA(insert OID = 1247 (  pg_type		PGNSP 71 PGUID 0 1247 0 0 0 0 0 f f r 23 0 0 0 0 0 t f f f _null_ ));
  DESCR("");
! DATA(insert OID = 1249 (  pg_attribute	PGNSP 75 PGUID 0 1249 0 0 0 0 0 f f r 17 0 0 0 0 0 f f f f _null_ ));
  DESCR("");
! DATA(insert OID = 1255 (  pg_proc		PGNSP 81 PGUID 0 1255 0 0 0 0 0 f f r 18 0 0 0 0 0 t f f f _null_ ));
  DESCR("");
! DATA(insert OID = 1259 (  pg_class		PGNSP 83 PGUID 0 1259 0 0 0 0 0 f f r 25 0 0 0 0 0 t f f f _null_ ));
  DESCR("");
  
  #define		  RELKIND_INDEX			  'i'		/* secondary index */
--- 150,164 ----
   * ----------------
   */
  
! DATA(insert OID = 1247 (  pg_type		PGNSP 71 PGUID 0 1247 0 0 0 "(0,2)" f f r 23 0 0 0 0 0 t f f f _null_ ));
! DESCR("");
! DATA(insert OID = 1249 (  pg_attribute	PGNSP 75 PGUID 0 1249 0 0 0 "(0,3)" f f r 17 0 0 0 0 0 f f f f _null_ ));
  DESCR("");
! DATA(insert OID = 1255 (  pg_proc		PGNSP 81 PGUID 0 1255 0 0 0 "(0,4)" f f r 18 0 0 0 0 0 t f f f _null_ ));
  DESCR("");
! DATA(insert OID = 1259 (  pg_class		PGNSP 83 PGUID 0 1259 0 0 0 "(0,5)" f f r 24 0 0 0 0 0 t f f f _null_ ));
  DESCR("");
! DATA(insert OID = 1004 (  pg_class_nt	PGNSP 86 PGUID 0 1004 0 0 0 "(0,6)" f f n  2 0 0 0 0 0 f f f f _null_ ));
  DESCR("");
  
  #define		  RELKIND_INDEX			  'i'		/* secondary index */
***************
*** 155,159 ****
--- 168,173 ----
  #define		  RELKIND_TOASTVALUE	  't'		/* moved off huge values */
  #define		  RELKIND_VIEW			  'v'		/* view */
  #define		  RELKIND_COMPOSITE_TYPE  'c'		/* composite type */
+ #define		  RELKIND_NON_TRANSACTIONAL 'n'		/* non-transactional heap */
  
  #endif   /* PG_CLASS_H */
Index: src/include/catalog/pg_type.h
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/include/catalog/pg_type.h,v
retrieving revision 1.171
diff -c -r1.171 pg_type.h
*** src/include/catalog/pg_type.h	5 Apr 2006 22:11:57 -0000	1.171
--- src/include/catalog/pg_type.h	12 Jun 2006 03:38:34 -0000
***************
*** 314,319 ****
--- 314,321 ----
  #define PG_PROC_RELTYPE_OID 81
  DATA(insert OID = 83 (	pg_class		PGNSP PGUID -1 f c t \054 1259 0 record_in record_out record_recv record_send - d x f 0 -1 0 _null_ _null_ ));
  #define PG_CLASS_RELTYPE_OID 83
+ DATA(insert OID = 86 (	pg_class_nt		PGNSP PGUID -1 f c t \054 1004 0 record_in record_out record_recv record_send - d x f 0 -1 0 _null_ _null_ ));
+ #define PG_CLASS_NT_RELTYPE_OID 86
  
  /* OIDS 100 - 199 */
  
Index: src/include/commands/vacuum.h
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/include/commands/vacuum.h,v
retrieving revision 1.63
diff -c -r1.63 vacuum.h
*** src/include/commands/vacuum.h	5 Mar 2006 15:58:55 -0000	1.63
--- src/include/commands/vacuum.h	5 Jun 2006 02:36:52 -0000
***************
*** 114,120 ****
  extern void vac_open_indexes(Relation relation, LOCKMODE lockmode,
  				 int *nindexes, Relation **Irel);
  extern void vac_close_indexes(int nindexes, Relation *Irel, LOCKMODE lockmode);
! extern void vac_update_relstats(Oid relid,
  					BlockNumber num_pages,
  					double num_tuples,
  					bool hasindex);
--- 114,120 ----
  extern void vac_open_indexes(Relation relation, LOCKMODE lockmode,
  				 int *nindexes, Relation **Irel);
  extern void vac_close_indexes(int nindexes, Relation *Irel, LOCKMODE lockmode);
! extern void vac_update_relstats(Relation rel,
  					BlockNumber num_pages,
  					double num_tuples,
  					bool hasindex);
Index: src/test/regress/expected/stats.out
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/test/regress/expected/stats.out,v
retrieving revision 1.7
diff -c -r1.7 stats.out
*** src/test/regress/expected/stats.out	11 Jan 2006 20:12:42 -0000	1.7
--- src/test/regress/expected/stats.out	12 Jun 2006 03:53:48 -0000
***************
*** 2,8 ****
  -- Test Statistics Collector
  --
  -- Must be run after tenk2 has been created (by create_table),
! -- populated (by create_misc) and indexed (by create_index).
  --
  -- conditio sine qua non
  SHOW stats_start_collector;  -- must be on
--- 2,8 ----
  -- Test Statistics Collector
  --
  -- Must be run after tenk2 has been created (by create_table),
! -- populated (by copy and create_misc) and indexed (by create_index).
  --
  -- conditio sine qua non
  SHOW stats_start_collector;  -- must be on
***************
*** 44,62 ****
  
  -- check effects
  SELECT st.seq_scan >= pr.seq_scan + 1,
!        st.seq_tup_read >= pr.seq_tup_read + cl.reltuples,
         st.idx_scan >= pr.idx_scan + 1,
         st.idx_tup_fetch >= pr.idx_tup_fetch + 1
!   FROM pg_stat_user_tables AS st, pg_class AS cl, prevstats AS pr
   WHERE st.relname='tenk2' AND cl.relname='tenk2';
   ?column? | ?column? | ?column? | ?column? 
  ----------+----------+----------+----------
   t        | t        | t        | t
  (1 row)
  
! SELECT st.heap_blks_read + st.heap_blks_hit >= pr.heap_blks + cl.relpages,
         st.idx_blks_read + st.idx_blks_hit >= pr.idx_blks + 1
!   FROM pg_statio_user_tables AS st, pg_class AS cl, prevstats AS pr
   WHERE st.relname='tenk2' AND cl.relname='tenk2';
   ?column? | ?column? 
  ----------+----------
--- 44,66 ----
  
  -- check effects
  SELECT st.seq_scan >= pr.seq_scan + 1,
!        st.seq_tup_read >= pr.seq_tup_read + nt.reltuples,
         st.idx_scan >= pr.idx_scan + 1,
         st.idx_tup_fetch >= pr.idx_tup_fetch + 1
!   FROM pg_stat_user_tables AS st,
!        pg_class AS cl JOIN pg_class_nt AS nt ON (nt.ctid = cl.relntrans),
!        prevstats AS pr
   WHERE st.relname='tenk2' AND cl.relname='tenk2';
   ?column? | ?column? | ?column? | ?column? 
  ----------+----------+----------+----------
   t        | t        | t        | t
  (1 row)
  
! SELECT st.heap_blks_read + st.heap_blks_hit >= pr.heap_blks + nt.relpages,
         st.idx_blks_read + st.idx_blks_hit >= pr.idx_blks + 1
!   FROM pg_statio_user_tables AS st,
!        pg_class AS cl JOIN pg_class_nt AS nt ON (nt.ctid = cl.relntrans),
!        prevstats AS pr
   WHERE st.relname='tenk2' AND cl.relname='tenk2';
   ?column? | ?column? 
  ----------+----------
Index: src/test/regress/expected/type_sanity.out
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/test/regress/expected/type_sanity.out,v
retrieving revision 1.27
diff -c -r1.27 type_sanity.out
*** src/test/regress/expected/type_sanity.out	10 Jul 2005 21:14:00 -0000	1.27
--- src/test/regress/expected/type_sanity.out	5 Jun 2006 02:36:52 -0000
***************
*** 216,222 ****
  -- Look for illegal values in pg_class fields
  SELECT p1.oid, p1.relname
  FROM pg_class as p1
! WHERE p1.relkind NOT IN ('r', 'i', 's', 'S', 'c', 't', 'v');
   oid | relname 
  -----+---------
  (0 rows)
--- 216,222 ----
  -- Look for illegal values in pg_class fields
  SELECT p1.oid, p1.relname
  FROM pg_class as p1
! WHERE p1.relkind NOT IN ('r', 'i', 's', 'S', 'c', 't', 'v', 'n');
   oid | relname 
  -----+---------
  (0 rows)
Index: src/test/regress/expected/without_oid.out
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/test/regress/expected/without_oid.out,v
retrieving revision 1.7
diff -c -r1.7 without_oid.out
*** src/test/regress/expected/without_oid.out	14 Mar 2006 22:48:25 -0000	1.7
--- src/test/regress/expected/without_oid.out	12 Jun 2006 03:54:15 -0000
***************
*** 48,54 ****
  VACUUM ANALYZE wi;
  VACUUM ANALYZE wo;
  SELECT min(relpages) < max(relpages), min(reltuples) - max(reltuples)
!   FROM pg_class
   WHERE relname IN ('wi', 'wo');
   ?column? | ?column? 
  ----------+----------
--- 48,54 ----
  VACUUM ANALYZE wi;
  VACUUM ANALYZE wo;
  SELECT min(relpages) < max(relpages), min(reltuples) - max(reltuples)
!   FROM pg_class JOIN pg_class_nt ON (pg_class_nt.ctid = relntrans)
   WHERE relname IN ('wi', 'wo');
   ?column? | ?column? 
  ----------+----------
Index: src/test/regress/sql/stats.sql
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/test/regress/sql/stats.sql,v
retrieving revision 1.5
diff -c -r1.5 stats.sql
*** src/test/regress/sql/stats.sql	11 Jan 2006 20:12:43 -0000	1.5
--- src/test/regress/sql/stats.sql	12 Jun 2006 03:54:50 -0000
***************
*** 2,8 ****
  -- Test Statistics Collector
  --
  -- Must be run after tenk2 has been created (by create_table),
! -- populated (by create_misc) and indexed (by create_index).
  --
  
  -- conditio sine qua non
--- 2,8 ----
  -- Test Statistics Collector
  --
  -- Must be run after tenk2 has been created (by create_table),
! -- populated (by copy and create_misc) and indexed (by create_index).
  --
  
  -- conditio sine qua non
***************
*** 30,43 ****
  
  -- check effects
  SELECT st.seq_scan >= pr.seq_scan + 1,
!        st.seq_tup_read >= pr.seq_tup_read + cl.reltuples,
         st.idx_scan >= pr.idx_scan + 1,
         st.idx_tup_fetch >= pr.idx_tup_fetch + 1
!   FROM pg_stat_user_tables AS st, pg_class AS cl, prevstats AS pr
   WHERE st.relname='tenk2' AND cl.relname='tenk2';
! SELECT st.heap_blks_read + st.heap_blks_hit >= pr.heap_blks + cl.relpages,
         st.idx_blks_read + st.idx_blks_hit >= pr.idx_blks + 1
!   FROM pg_statio_user_tables AS st, pg_class AS cl, prevstats AS pr
   WHERE st.relname='tenk2' AND cl.relname='tenk2';
  
  -- End of Stats Test
--- 30,47 ----
  
  -- check effects
  SELECT st.seq_scan >= pr.seq_scan + 1,
!        st.seq_tup_read >= pr.seq_tup_read + nt.reltuples,
         st.idx_scan >= pr.idx_scan + 1,
         st.idx_tup_fetch >= pr.idx_tup_fetch + 1
!   FROM pg_stat_user_tables AS st,
!        pg_class AS cl JOIN pg_class_nt AS nt ON (nt.ctid = cl.relntrans),
!        prevstats AS pr
   WHERE st.relname='tenk2' AND cl.relname='tenk2';
! SELECT st.heap_blks_read + st.heap_blks_hit >= pr.heap_blks + nt.relpages,
         st.idx_blks_read + st.idx_blks_hit >= pr.idx_blks + 1
!   FROM pg_statio_user_tables AS st,
!        pg_class AS cl JOIN pg_class_nt AS nt ON (nt.ctid = cl.relntrans),
!        prevstats AS pr
   WHERE st.relname='tenk2' AND cl.relname='tenk2';
  
  -- End of Stats Test
Index: src/test/regress/sql/type_sanity.sql
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/test/regress/sql/type_sanity.sql,v
retrieving revision 1.27
diff -c -r1.27 type_sanity.sql
*** src/test/regress/sql/type_sanity.sql	10 Jul 2005 21:14:00 -0000	1.27
--- src/test/regress/sql/type_sanity.sql	5 Jun 2006 02:36:52 -0000
***************
*** 169,175 ****
  
  SELECT p1.oid, p1.relname
  FROM pg_class as p1
! WHERE p1.relkind NOT IN ('r', 'i', 's', 'S', 'c', 't', 'v');
  
  -- Indexes should have an access method, others not.
  
--- 169,175 ----
  
  SELECT p1.oid, p1.relname
  FROM pg_class as p1
! WHERE p1.relkind NOT IN ('r', 'i', 's', 'S', 'c', 't', 'v', 'n');
  
  -- Indexes should have an access method, others not.
  
Index: src/test/regress/sql/without_oid.sql
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/test/regress/sql/without_oid.sql,v
retrieving revision 1.6
diff -c -r1.6 without_oid.sql
*** src/test/regress/sql/without_oid.sql	19 Feb 2006 00:04:28 -0000	1.6
--- src/test/regress/sql/without_oid.sql	12 Jun 2006 03:55:11 -0000
***************
*** 45,51 ****
  VACUUM ANALYZE wo;
  
  SELECT min(relpages) < max(relpages), min(reltuples) - max(reltuples)
!   FROM pg_class
   WHERE relname IN ('wi', 'wo');
  
  DROP TABLE wi;
--- 45,51 ----
  VACUUM ANALYZE wo;
  
  SELECT min(relpages) < max(relpages), min(reltuples) - max(reltuples)
!   FROM pg_class JOIN pg_class_nt ON (pg_class_nt.ctid = relntrans)
   WHERE relname IN ('wi', 'wo');
  
  DROP TABLE wi;

Index: doc/src/sgml/catalogs.sgml
===================================================================
RCS file: /home/alvherre/cvs/pgsql/doc/src/sgml/catalogs.sgml,v
retrieving revision 2.124
diff -c -r2.124 catalogs.sgml
*** doc/src/sgml/catalogs.sgml	3 Jun 2006 02:53:04 -0000	2.124
--- doc/src/sgml/catalogs.sgml	28 Jun 2006 18:02:59 -0000
***************
*** 1633,1638 ****
--- 1633,1662 ----
       </row>
  
       <row>
+       <entry><structfield>relminxid</structfield></entry>
+       <entry><type>xid</type></entry>
+       <entry></entry>
+       <entry>
+        The minimum transaction ID present in all rows in this table.  This
+        value is used to determine the database-global
+        <structname>pg_database</>.<structfield>datminxid</> value.
+       </entry>
+      </row>
+ 
+      <row>
+       <entry><structfield>relvacuumxid</structfield></entry>
+       <entry><type>xid</type></entry>
+       <entry></entry>
+       <entry>
+        The transaction ID that was used as cleaning point as of the last vacuum
+        operation.  All rows inserted, updated or deleted in this table by
+        transactions whose IDs are below this one have been marked as known good
+        or deleted.  This is used to determine the database-global
+        <structname>pg_database</>.<structfield>datvacuumxid</> value.
+       </entry>
+      </row>
+ 
+      <row>
        <entry><structfield>relacl</structfield></entry>
        <entry><type>aclitem[]</type></entry>
        <entry></entry>
***************
*** 2006,2026 ****
        <entry><type>xid</type></entry>
        <entry></entry>
        <entry>
!        All rows inserted or deleted by transaction IDs before this one
!        have been marked as known committed or known aborted in this database.
!        This is used to determine when commit-log space can be recycled.
        </entry>
       </row>
  
       <row>
!       <entry><structfield>datfrozenxid</structfield></entry>
        <entry><type>xid</type></entry>
        <entry></entry>
        <entry>
         All rows inserted by transaction IDs before this one have been
         relabeled with a permanent (<quote>frozen</>) transaction ID in this
!        database.  This is useful to check whether a database must be vacuumed
!        soon to avoid transaction ID wrap-around problems.
        </entry>
       </row>
  
--- 2030,2056 ----
        <entry><type>xid</type></entry>
        <entry></entry>
        <entry>
!        The transaction ID that was used as cleaning point as of the last vacuum
!        operation.  All rows inserted or deleted by transaction IDs before this one
!        have been marked as known good or deleted.  This
!        is used to determine when commit-log space can be recycled.
!        If InvalidTransactionId, then the minimum is unknown and can be
!        determined by scanning <structname>pg_class</>.<structfield>relvacuumxid</>.
        </entry>
       </row>
  
       <row>
!       <entry><structfield>datminxid</structfield></entry>
        <entry><type>xid</type></entry>
        <entry></entry>
        <entry>
+        The minimum transaction ID present in all tables in this database.
         All rows inserted by transaction IDs before this one have been
         relabeled with a permanent (<quote>frozen</>) transaction ID in this
!        database.  This is useful to check whether a database must be
!        vacuumed soon to avoid transaction ID wrap-around problems.
!        If InvalidTransactionId, then the minimum is unknown and can be
!        determined by scanning <structname>pg_class</>.<structfield>relminxid</>.
        </entry>
       </row>
  
Index: src/backend/access/transam/varsup.c
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/access/transam/varsup.c,v
retrieving revision 1.70
diff -c -r1.70 varsup.c
*** src/backend/access/transam/varsup.c	5 Mar 2006 15:58:22 -0000	1.70
--- src/backend/access/transam/varsup.c	28 Jun 2006 18:02:59 -0000
***************
*** 168,178 ****
  
  /*
   * Determine the last safe XID to allocate given the currently oldest
!  * datfrozenxid (ie, the oldest XID that might exist in any database
   * of our cluster).
   */
  void
! SetTransactionIdLimit(TransactionId oldest_datfrozenxid,
  					  Name oldest_datname)
  {
  	TransactionId xidWarnLimit;
--- 168,178 ----
  
  /*
   * Determine the last safe XID to allocate given the currently oldest
!  * datminxid (ie, the oldest XID that might exist in any database
   * of our cluster).
   */
  void
! SetTransactionIdLimit(TransactionId oldest_datminxid,
  					  Name oldest_datname)
  {
  	TransactionId xidWarnLimit;
***************
*** 180,195 ****
  	TransactionId xidWrapLimit;
  	TransactionId curXid;
  
! 	Assert(TransactionIdIsValid(oldest_datfrozenxid));
  
  	/*
  	 * The place where we actually get into deep trouble is halfway around
! 	 * from the oldest potentially-existing XID.  (This calculation is
! 	 * probably off by one or two counts, because the special XIDs reduce the
! 	 * size of the loop a little bit.  But we throw in plenty of slop below,
! 	 * so it doesn't matter.)
  	 */
! 	xidWrapLimit = oldest_datfrozenxid + (MaxTransactionId >> 1);
  	if (xidWrapLimit < FirstNormalTransactionId)
  		xidWrapLimit += FirstNormalTransactionId;
  
--- 180,195 ----
  	TransactionId xidWrapLimit;
  	TransactionId curXid;
  
! 	Assert(TransactionIdIsValid(oldest_datminxid));
  
  	/*
  	 * The place where we actually get into deep trouble is halfway around
! 	 * from the oldest existing XID.  (This calculation is probably off by one
! 	 * or two counts, because the special XIDs reduce the size of the loop a
! 	 * little bit.  But we throw in plenty of slop below, so it doesn't
! 	 * matter.)
  	 */
! 	xidWrapLimit = oldest_datminxid + (MaxTransactionId >> 1);
  	if (xidWrapLimit < FirstNormalTransactionId)
  		xidWrapLimit += FirstNormalTransactionId;
  
Index: src/backend/catalog/heap.c
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/catalog/heap.c,v
retrieving revision 1.299
diff -c -r1.299 heap.c
*** src/backend/catalog/heap.c	10 May 2006 23:18:39 -0000	1.299
--- src/backend/catalog/heap.c	28 Jun 2006 22:04:56 -0000
***************
*** 568,573 ****
--- 568,602 ----
  	 */
  	new_rel_reltup = new_rel_desc->rd_rel;
  
+ 	/* Initialize relminxid and relvacuumxid */
+ 	if (relkind == RELKIND_RELATION ||
+ 		relkind == RELKIND_TOASTVALUE)
+ 	{
+ 		/*
+ 		 * Only real tables have Xids stored in them; initialize our known
+ 		 * value to the minimum Xid that could put tuples in the new table.
+ 		 */
+ 		if (!IsBootstrapProcessingMode())
+ 		{
+ 			new_rel_reltup->relminxid = RecentXmin;
+ 			new_rel_reltup->relvacuumxid = RecentXmin;
+ 		}
+ 		else
+ 		{
+ 			new_rel_reltup->relminxid = FirstNormalTransactionId;
+ 			new_rel_reltup->relvacuumxid = FirstNormalTransactionId;
+ 		}
+ 	}
+ 	else
+ 	{
+ 		/*
+ 		 * Other relations will not have Xids in them, so set the initial value
+ 		 * to InvalidTransactionId.
+ 		 */
+ 		new_rel_reltup->relminxid = InvalidTransactionId;
+ 		new_rel_reltup->relvacuumxid = InvalidTransactionId;
+ 	}
+ 
  	switch (relkind)
  	{
  		case RELKIND_RELATION:
Index: src/backend/commands/analyze.c
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/commands/analyze.c,v
retrieving revision 1.93
diff -c -r1.93 analyze.c
*** src/backend/commands/analyze.c	23 Mar 2006 00:19:28 -0000	1.93
--- src/backend/commands/analyze.c	28 Jun 2006 18:02:59 -0000
***************
*** 424,431 ****
  	{
  		vac_update_relstats(RelationGetRelid(onerel),
  							RelationGetNumberOfBlocks(onerel),
! 							totalrows,
! 							hasindex);
  		for (ind = 0; ind < nindexes; ind++)
  		{
  			AnlIndexData *thisdata = &indexdata[ind];
--- 424,432 ----
  	{
  		vac_update_relstats(RelationGetRelid(onerel),
  							RelationGetNumberOfBlocks(onerel),
! 							totalrows, hasindex,
! 							InvalidTransactionId, InvalidTransactionId);
! 
  		for (ind = 0; ind < nindexes; ind++)
  		{
  			AnlIndexData *thisdata = &indexdata[ind];
***************
*** 434,441 ****
  			totalindexrows = ceil(thisdata->tupleFract * totalrows);
  			vac_update_relstats(RelationGetRelid(Irel[ind]),
  								RelationGetNumberOfBlocks(Irel[ind]),
! 								totalindexrows,
! 								false);
  		}
  
  		/* report results to the stats collector, too */
--- 435,442 ----
  			totalindexrows = ceil(thisdata->tupleFract * totalrows);
  			vac_update_relstats(RelationGetRelid(Irel[ind]),
  								RelationGetNumberOfBlocks(Irel[ind]),
! 								totalindexrows, false,
! 								InvalidTransactionId, InvalidTransactionId);
  		}
  
  		/* report results to the stats collector, too */
Index: src/backend/commands/dbcommands.c
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/commands/dbcommands.c,v
retrieving revision 1.181
diff -c -r1.181 dbcommands.c
*** src/backend/commands/dbcommands.c	4 May 2006 16:07:29 -0000	1.181
--- src/backend/commands/dbcommands.c	28 Jun 2006 18:24:18 -0000
***************
*** 55,61 ****
  			Oid *dbIdP, Oid *ownerIdP,
  			int *encodingP, bool *dbIsTemplateP, bool *dbAllowConnP,
  			Oid *dbLastSysOidP,
! 			TransactionId *dbVacuumXidP, TransactionId *dbFrozenXidP,
  			Oid *dbTablespace);
  static bool have_createdb_privilege(void);
  static void remove_dbtablespaces(Oid db_id);
--- 55,61 ----
  			Oid *dbIdP, Oid *ownerIdP,
  			int *encodingP, bool *dbIsTemplateP, bool *dbAllowConnP,
  			Oid *dbLastSysOidP,
! 			TransactionId *dbVacuumXidP, TransactionId *dbMinXidP,
  			Oid *dbTablespace);
  static bool have_createdb_privilege(void);
  static void remove_dbtablespaces(Oid db_id);
***************
*** 76,82 ****
  	bool		src_allowconn;
  	Oid			src_lastsysoid;
  	TransactionId src_vacuumxid;
! 	TransactionId src_frozenxid;
  	Oid			src_deftablespace;
  	volatile Oid dst_deftablespace;
  	Relation	pg_database_rel;
--- 76,82 ----
  	bool		src_allowconn;
  	Oid			src_lastsysoid;
  	TransactionId src_vacuumxid;
! 	TransactionId src_minxid;
  	Oid			src_deftablespace;
  	volatile Oid dst_deftablespace;
  	Relation	pg_database_rel;
***************
*** 228,234 ****
  	if (!get_db_info(dbtemplate, ShareLock,
  					 &src_dboid, &src_owner, &src_encoding,
  					 &src_istemplate, &src_allowconn, &src_lastsysoid,
! 					 &src_vacuumxid, &src_frozenxid, &src_deftablespace))
  		ereport(ERROR,
  				(errcode(ERRCODE_UNDEFINED_DATABASE),
  				 errmsg("template database \"%s\" does not exist",
--- 228,234 ----
  	if (!get_db_info(dbtemplate, ShareLock,
  					 &src_dboid, &src_owner, &src_encoding,
  					 &src_istemplate, &src_allowconn, &src_lastsysoid,
! 					 &src_vacuumxid, &src_minxid, &src_deftablespace))
  		ereport(ERROR,
  				(errcode(ERRCODE_UNDEFINED_DATABASE),
  				 errmsg("template database \"%s\" does not exist",
***************
*** 327,342 ****
  	}
  
  	/*
- 	 * Normally we mark the new database with the same datvacuumxid and
- 	 * datfrozenxid as the source.	However, if the source is not allowing
- 	 * connections then we assume it is fully frozen, and we can set the
- 	 * current transaction ID as the xid limits.  This avoids immediately
- 	 * starting to generate warnings after cloning template0.
- 	 */
- 	if (!src_allowconn)
- 		src_vacuumxid = src_frozenxid = GetCurrentTransactionId();
- 
- 	/*
  	 * Check for db name conflict.	This is just to give a more friendly
  	 * error message than "unique index violation".  There's a race condition
  	 * but we're willing to accept the less friendly message in that case.
--- 327,332 ----
***************
*** 367,373 ****
  	new_record[Anum_pg_database_datconnlimit - 1] = Int32GetDatum(dbconnlimit);
  	new_record[Anum_pg_database_datlastsysoid - 1] = ObjectIdGetDatum(src_lastsysoid);
  	new_record[Anum_pg_database_datvacuumxid - 1] = TransactionIdGetDatum(src_vacuumxid);
! 	new_record[Anum_pg_database_datfrozenxid - 1] = TransactionIdGetDatum(src_frozenxid);
  	new_record[Anum_pg_database_dattablespace - 1] = ObjectIdGetDatum(dst_deftablespace);
  
  	/*
--- 357,363 ----
  	new_record[Anum_pg_database_datconnlimit - 1] = Int32GetDatum(dbconnlimit);
  	new_record[Anum_pg_database_datlastsysoid - 1] = ObjectIdGetDatum(src_lastsysoid);
  	new_record[Anum_pg_database_datvacuumxid - 1] = TransactionIdGetDatum(src_vacuumxid);
! 	new_record[Anum_pg_database_datminxid - 1] = TransactionIdGetDatum(src_minxid);
  	new_record[Anum_pg_database_dattablespace - 1] = ObjectIdGetDatum(dst_deftablespace);
  
  	/*
***************
*** 1066,1072 ****
  			Oid *dbIdP, Oid *ownerIdP,
  			int *encodingP, bool *dbIsTemplateP, bool *dbAllowConnP,
  			Oid *dbLastSysOidP,
! 			TransactionId *dbVacuumXidP, TransactionId *dbFrozenXidP,
  			Oid *dbTablespace)
  {
  	bool		result = false;
--- 1056,1062 ----
  			Oid *dbIdP, Oid *ownerIdP,
  			int *encodingP, bool *dbIsTemplateP, bool *dbAllowConnP,
  			Oid *dbLastSysOidP,
! 			TransactionId *dbVacuumXidP, TransactionId *dbMinXidP,
  			Oid *dbTablespace)
  {
  	bool		result = false;
***************
*** 1155,1163 ****
  				/* limit of vacuumed XIDs */
  				if (dbVacuumXidP)
  					*dbVacuumXidP = dbform->datvacuumxid;
! 				/* limit of frozen XIDs */
! 				if (dbFrozenXidP)
! 					*dbFrozenXidP = dbform->datfrozenxid;
  				/* default tablespace for this database */
  				if (dbTablespace)
  					*dbTablespace = dbform->dattablespace;
--- 1145,1153 ----
  				/* limit of vacuumed XIDs */
  				if (dbVacuumXidP)
  					*dbVacuumXidP = dbform->datvacuumxid;
! 				/* limit of min XIDs */
! 				if (dbMinXidP)
! 					*dbMinXidP = dbform->datminxid;
  				/* default tablespace for this database */
  				if (dbTablespace)
  					*dbTablespace = dbform->dattablespace;
Index: src/backend/commands/vacuum.c
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/commands/vacuum.c,v
retrieving revision 1.330
diff -c -r1.330 vacuum.c
*** src/backend/commands/vacuum.c	10 May 2006 23:18:39 -0000	1.330
--- src/backend/commands/vacuum.c	28 Jun 2006 23:28:37 -0000
***************
*** 25,30 ****
--- 25,31 ----
  #include "access/clog.h"
  #include "access/genam.h"
  #include "access/heapam.h"
+ #include "access/multixact.h"
  #include "access/subtrans.h"
  #include "access/xlog.h"
  #include "catalog/catalog.h"
***************
*** 127,132 ****
--- 128,134 ----
  	Size		min_tlen;
  	Size		max_tlen;
  	bool		hasindex;
+ 	TransactionId minxid;	/* Minimum Xid present anywhere on table */
  	/* vtlinks array for tuple chain following - sorted by new_tid */
  	int			num_vtlinks;
  	VTupleLink	vtlinks;
***************
*** 194,218 ****
  
  static int	elevel = -1;
  
- static TransactionId OldestXmin;
- static TransactionId FreezeLimit;
- 
  
  /* non-export function prototypes */
  static List *get_rel_oids(List *relids, const RangeVar *vacrel,
  			 const char *stmttype);
! static void vac_update_dbstats(Oid dbid,
! 				   TransactionId vacuumXID,
! 				   TransactionId frozenXID);
! static void vac_truncate_clog(TransactionId vacuumXID,
! 				  TransactionId frozenXID);
! static bool vacuum_rel(Oid relid, VacuumStmt *vacstmt, char expected_relkind);
  static void full_vacuum_rel(Relation onerel, VacuumStmt *vacstmt);
  static void scan_heap(VRelStats *vacrelstats, Relation onerel,
! 		  VacPageList vacuum_pages, VacPageList fraged_pages);
  static void repair_frag(VRelStats *vacrelstats, Relation onerel,
  			VacPageList vacuum_pages, VacPageList fraged_pages,
! 			int nindexes, Relation *Irel);
  static void move_chain_tuple(Relation rel,
  				 Buffer old_buf, Page old_page, HeapTuple old_tup,
  				 Buffer dst_buf, Page dst_page, VacPage dst_vacpage,
--- 196,217 ----
  
  static int	elevel = -1;
  
  
  /* non-export function prototypes */
  static List *get_rel_oids(List *relids, const RangeVar *vacrel,
  			 const char *stmttype);
! static void vac_update_dbminxid(Oid dbid,
! 					TransactionId *minxid,
! 					TransactionId *vacuumxid);
! static void vac_truncate_clog(TransactionId myminxid, TransactionId myvacxid);
! static void vacuum_rel(Oid relid, VacuumStmt *vacstmt, char expected_relkind);
  static void full_vacuum_rel(Relation onerel, VacuumStmt *vacstmt);
  static void scan_heap(VRelStats *vacrelstats, Relation onerel,
! 		  VacPageList vacuum_pages, VacPageList fraged_pages,
! 		  TransactionId FreezeLimit, TransactionId OldestXmin);
  static void repair_frag(VRelStats *vacrelstats, Relation onerel,
  			VacPageList vacuum_pages, VacPageList fraged_pages,
! 			int nindexes, Relation *Irel, TransactionId OldestXmin);
  static void move_chain_tuple(Relation rel,
  				 Buffer old_buf, Page old_page, HeapTuple old_tup,
  				 Buffer dst_buf, Page dst_page, VacPage dst_vacpage,
***************
*** 268,275 ****
  vacuum(VacuumStmt *vacstmt, List *relids)
  {
  	const char *stmttype = vacstmt->vacuum ? "VACUUM" : "ANALYZE";
- 	TransactionId initialOldestXmin = InvalidTransactionId;
- 	TransactionId initialFreezeLimit = InvalidTransactionId;
  	volatile MemoryContext anl_context = NULL;
  	volatile bool all_rels,
  				in_outer_xact,
--- 267,272 ----
***************
*** 352,383 ****
  	 */
  	relations = get_rel_oids(relids, vacstmt->relation, stmttype);
  
- 	if (vacstmt->vacuum && all_rels)
- 	{
- 		/*
- 		 * It's a database-wide VACUUM.
- 		 *
- 		 * Compute the initially applicable OldestXmin and FreezeLimit XIDs,
- 		 * so that we can record these values at the end of the VACUUM. Note
- 		 * that individual tables may well be processed with newer values, but
- 		 * we can guarantee that no (non-shared) relations are processed with
- 		 * older ones.
- 		 *
- 		 * It is okay to record non-shared values in pg_database, even though
- 		 * we may vacuum shared relations with older cutoffs, because only the
- 		 * minimum of the values present in pg_database matters.  We can be
- 		 * sure that shared relations have at some time been vacuumed with
- 		 * cutoffs no worse than the global minimum; for, if there is a
- 		 * backend in some other DB with xmin = OLDXMIN that's determining the
- 		 * cutoff with which we vacuum shared relations, it is not possible
- 		 * for that database to have a cutoff newer than OLDXMIN recorded in
- 		 * pg_database.
- 		 */
- 		vacuum_set_xid_limits(vacstmt, false,
- 							  &initialOldestXmin,
- 							  &initialFreezeLimit);
- 	}
- 
  	/*
  	 * Decide whether we need to start/commit our own transactions.
  	 *
--- 349,354 ----
***************
*** 445,454 ****
  			Oid			relid = lfirst_oid(cur);
  
  			if (vacstmt->vacuum)
! 			{
! 				if (!vacuum_rel(relid, vacstmt, RELKIND_RELATION))
! 					all_rels = false;	/* forget about updating dbstats */
! 			}
  			if (vacstmt->analyze)
  			{
  				MemoryContext old_context = NULL;
--- 416,423 ----
  			Oid			relid = lfirst_oid(cur);
  
  			if (vacstmt->vacuum)
! 				vacuum_rel(relid, vacstmt, RELKIND_RELATION);
! 
  			if (vacstmt->analyze)
  			{
  				MemoryContext old_context = NULL;
***************
*** 524,529 ****
--- 493,501 ----
  
  	if (vacstmt->vacuum)
  	{
+ 		TransactionId	minxid,
+ 						vacuumxid;
+ 
  		/*
  		 * If it was a database-wide VACUUM, print FSM usage statistics (we
  		 * don't make you be superuser to see these).
***************
*** 531,547 ****
  		if (all_rels)
  			PrintFreeSpaceMapStatistics(elevel);
  
! 		/*
! 		 * If we completed a database-wide VACUUM without skipping any
! 		 * relations, update the database's pg_database row with info about
! 		 * the transaction IDs used, and try to truncate pg_clog.
! 		 */
! 		if (all_rels)
! 		{
! 			vac_update_dbstats(MyDatabaseId,
! 							   initialOldestXmin, initialFreezeLimit);
! 			vac_truncate_clog(initialOldestXmin, initialFreezeLimit);
! 		}
  	}
  
  	/*
--- 503,513 ----
  		if (all_rels)
  			PrintFreeSpaceMapStatistics(elevel);
  
! 		/* Update pg_database.datminxid and datvacuumxid */
! 		vac_update_dbminxid(MyDatabaseId, &minxid, &vacuumxid);
! 
! 		/* Try to truncate pg_clog. */
! 		vac_truncate_clog(minxid, vacuumxid);
  	}
  
  	/*
***************
*** 687,693 ****
   */
  void
  vac_update_relstats(Oid relid, BlockNumber num_pages, double num_tuples,
! 					bool hasindex)
  {
  	Relation	rd;
  	HeapTuple	ctup;
--- 653,660 ----
   */
  void
  vac_update_relstats(Oid relid, BlockNumber num_pages, double num_tuples,
! 					bool hasindex, TransactionId minxid,
! 					TransactionId vacuumxid)
  {
  	Relation	rd;
  	HeapTuple	ctup;
***************
*** 735,740 ****
--- 702,717 ----
  			dirty = true;
  		}
  	}
+ 	if (TransactionIdIsValid(minxid) && pgcform->relminxid != minxid)
+ 	{
+ 		pgcform->relminxid = minxid;
+ 		dirty = true;
+ 	}
+ 	if (TransactionIdIsValid(vacuumxid) && pgcform->relvacuumxid != vacuumxid)
+ 	{
+ 		pgcform->relvacuumxid = vacuumxid;
+ 		dirty = true;
+ 	}
  
  	/*
  	 * If anything changed, write out the tuple
***************
*** 747,756 ****
  
  
  /*
!  *	vac_update_dbstats() -- update statistics for one database
   *
!  *		Update the whole-database statistics that are kept in its pg_database
!  *		row, and the flat-file copy of pg_database.
   *
   *		We violate transaction semantics here by overwriting the database's
   *		existing pg_database tuple with the new values.  This is reasonably
--- 724,736 ----
  
  
  /*
!  *	vac_update_dbminxid() -- update the minimum Xid present in one database
   *
!  * 		Update pg_database's datminxid and datvacuumxid, and the flat-file copy
!  * 		of it.  datminxid is updated to the minimum of all relminxid found in
!  * 		pg_class.  datvacuumxid is updated to the minimum of all relvacuumxid
!  * 		found in pg_class.  The values are also returned in minxid and
!  * 		vacuumxid, respectively.
   *
   *		We violate transaction semantics here by overwriting the database's
   *		existing pg_database tuple with the new values.  This is reasonably
***************
*** 758,775 ****
   *		commits.  As with vac_update_relstats, this avoids leaving dead tuples
   *		behind after a VACUUM.
   *
!  *		This routine is shared by full and lazy VACUUM.  Note that it is only
!  *		applied after a database-wide VACUUM operation.
   */
  static void
! vac_update_dbstats(Oid dbid,
! 				   TransactionId vacuumXID,
! 				   TransactionId frozenXID)
  {
- 	Relation	relation;
  	HeapTuple	tuple;
  	Form_pg_database dbform;
  
  	relation = heap_open(DatabaseRelationId, RowExclusiveLock);
  
  	/* Fetch a copy of the tuple to scribble on */
--- 738,804 ----
   *		commits.  As with vac_update_relstats, this avoids leaving dead tuples
   *		behind after a VACUUM.
   *
!  *		This routine is shared by full and lazy VACUUM.
   */
  static void
! vac_update_dbminxid(Oid dbid, TransactionId *minxid, TransactionId *vacuumxid)
  {
  	HeapTuple	tuple;
  	Form_pg_database dbform;
+ 	Relation	relation;
+ 	SysScanDesc	scan;
+ 	HeapTuple	classTup;
+ 	TransactionId	newMinXid = InvalidTransactionId;
+ 	TransactionId	newVacXid = InvalidTransactionId;
+ 	bool		dirty = false;
+ 
+ 	/* 
+ 	 * We must seqscan pg_class to find the minimum Xid, because there
+ 	 * is no index that can help us here.
+ 	 */
+ 	relation = heap_open(RelationRelationId, AccessShareLock);
+ 
+ 	scan = systable_beginscan(relation, InvalidOid, false,
+ 							  SnapshotNow, 0, NULL);
+ 
+ 	while ((classTup = systable_getnext(scan)) != NULL)
+ 	{
+ 		Form_pg_class classForm;
+ 
+ 		classForm = (Form_pg_class) GETSTRUCT(classTup);
+ 
+ 		/*
+ 		 * Only consider heap and TOAST tables (anything else should have
+ 		 * InvalidTransactionId in both fields anyway.)
+ 		 */
+ 		if (classForm->relkind != RELKIND_RELATION &&
+ 			classForm->relkind != RELKIND_TOASTVALUE)
+ 			continue;
+ 
+ 		Assert(TransactionIdIsNormal(classForm->relminxid));
+ 		Assert(TransactionIdIsNormal(classForm->relvacuumxid));
+ 
+ 		/*
+ 		 * Compute the minimum relminxid in all the tables in the database.
+ 		 */
+ 		if ((!TransactionIdIsValid(newMinXid) ||
+ 			 TransactionIdPrecedes(classForm->relminxid, newMinXid)))
+ 			newMinXid = classForm->relminxid;
+ 
+ 		/* ditto, for relvacuumxid */
+ 		if ((!TransactionIdIsValid(newVacXid) ||
+ 			 TransactionIdPrecedes(classForm->relvacuumxid, newVacXid)))
+ 			newVacXid = classForm->relvacuumxid;
+ 	}
  
+ 	/* we're done with pg_class */
+ 	systable_endscan(scan);
+ 	heap_close(relation, AccessShareLock);
+ 
+ 	Assert(TransactionIdIsNormal(newMinXid));
+ 	Assert(TransactionIdIsNormal(newVacXid));
+ 
+ 	/* Now fetch the pg_database tuple we need to update. */
  	relation = heap_open(DatabaseRelationId, RowExclusiveLock);
  
  	/* Fetch a copy of the tuple to scribble on */
***************
*** 780,795 ****
  		elog(ERROR, "could not find tuple for database %u", dbid);
  	dbform = (Form_pg_database) GETSTRUCT(tuple);
  
! 	/* overwrite the existing statistics in the tuple */
! 	dbform->datvacuumxid = vacuumXID;
! 	dbform->datfrozenxid = frozenXID;
  
! 	heap_inplace_update(relation, tuple);
  
  	heap_close(relation, RowExclusiveLock);
  
! 	/* Mark the flat-file copy of pg_database for update at commit */
! 	database_file_update_needed();
  }
  
  
--- 809,834 ----
  		elog(ERROR, "could not find tuple for database %u", dbid);
  	dbform = (Form_pg_database) GETSTRUCT(tuple);
  
! 	if (TransactionIdPrecedes(dbform->datminxid, newMinXid))
! 	{
! 		dbform->datminxid = newMinXid;
! 		dirty = true;
! 	}
! 	if (TransactionIdPrecedes(dbform->datvacuumxid, newVacXid))
! 	{
! 		dbform->datvacuumxid = newVacXid;
! 		dirty = true;
! 	}
  
! 	if (dirty)
! 		heap_inplace_update(relation, tuple);
  
+ 	heap_freetuple(tuple);
  	heap_close(relation, RowExclusiveLock);
  
! 	/* set return values */
! 	*minxid = newMinXid;
! 	*vacuumxid = newVacXid;
  }
  
  
***************
*** 813,830 ****
   *		applied after a database-wide VACUUM operation.
   */
  static void
! vac_truncate_clog(TransactionId vacuumXID, TransactionId frozenXID)
  {
  	TransactionId myXID = GetCurrentTransactionId();
  	Relation	relation;
  	HeapScanDesc scan;
  	HeapTuple	tuple;
  	int32		age;
  	NameData	oldest_datname;
  	bool		vacuumAlreadyWrapped = false;
! 	bool		frozenAlreadyWrapped = false;
  
! 	/* init oldest_datname to sync with my frozenXID */
  	namestrcpy(&oldest_datname, get_database_name(MyDatabaseId));
  
  	/*
--- 852,873 ----
   *		applied after a database-wide VACUUM operation.
   */
  static void
! vac_truncate_clog(TransactionId myminxid, TransactionId myvacxid)
  {
  	TransactionId myXID = GetCurrentTransactionId();
+ 	TransactionId minXID;
+ 	TransactionId vacuumXID;
  	Relation	relation;
  	HeapScanDesc scan;
  	HeapTuple	tuple;
  	int32		age;
  	NameData	oldest_datname;
  	bool		vacuumAlreadyWrapped = false;
! 	bool		minAlreadyWrapped = false;
  
! 	/* Initialize the minimum values. */
! 	minXID = myminxid;
! 	vacuumXID = myvacxid;
  	namestrcpy(&oldest_datname, get_database_name(MyDatabaseId));
  
  	/*
***************
*** 839,865 ****
  	{
  		Form_pg_database dbform = (Form_pg_database) GETSTRUCT(tuple);
  
! 		/* Ignore non-connectable databases (eg, template0) */
! 		/* It's assumed that these have been frozen correctly */
! 		if (!dbform->datallowconn)
! 			continue;
  
! 		if (TransactionIdIsNormal(dbform->datvacuumxid))
  		{
! 			if (TransactionIdPrecedes(myXID, dbform->datvacuumxid))
! 				vacuumAlreadyWrapped = true;
! 			else if (TransactionIdPrecedes(dbform->datvacuumxid, vacuumXID))
! 				vacuumXID = dbform->datvacuumxid;
! 		}
! 		if (TransactionIdIsNormal(dbform->datfrozenxid))
! 		{
! 			if (TransactionIdPrecedes(myXID, dbform->datfrozenxid))
! 				frozenAlreadyWrapped = true;
! 			else if (TransactionIdPrecedes(dbform->datfrozenxid, frozenXID))
! 			{
! 				frozenXID = dbform->datfrozenxid;
! 				namecpy(&oldest_datname, &dbform->datname);
! 			}
  		}
  	}
  
--- 882,901 ----
  	{
  		Form_pg_database dbform = (Form_pg_database) GETSTRUCT(tuple);
  
! 		Assert(TransactionIdIsNormal(dbform->datvacuumxid));
! 		Assert(TransactionIdIsNormal(dbform->datminxid));
  
! 		if (TransactionIdPrecedes(myXID, dbform->datvacuumxid))
! 			vacuumAlreadyWrapped = true;
! 		else if (TransactionIdPrecedes(dbform->datvacuumxid, vacuumXID))
! 			vacuumXID = dbform->datvacuumxid;
! 
! 		if (TransactionIdPrecedes(myXID, dbform->datminxid))
! 			minAlreadyWrapped = true;
! 		else if (TransactionIdPrecedes(dbform->datminxid, minXID))
  		{
! 			minXID = dbform->datminxid;
! 			namecpy(&oldest_datname, &dbform->datname);
  		}
  	}
  
***************
*** 886,892 ****
  	 * Do not update varsup.c if we seem to have suffered wraparound already;
  	 * the computed XID might be bogus.
  	 */
! 	if (frozenAlreadyWrapped)
  	{
  		ereport(WARNING,
  				(errmsg("some databases have not been vacuumed in over 1 billion transactions"),
--- 922,928 ----
  	 * Do not update varsup.c if we seem to have suffered wraparound already;
  	 * the computed XID might be bogus.
  	 */
! 	if (minAlreadyWrapped)
  	{
  		ereport(WARNING,
  				(errmsg("some databases have not been vacuumed in over 1 billion transactions"),
***************
*** 895,904 ****
  	}
  
  	/* Update the wrap limit for GetNewTransactionId */
! 	SetTransactionIdLimit(frozenXID, &oldest_datname);
  
  	/* Give warning about impending wraparound problems */
! 	age = (int32) (myXID - frozenXID);
  	if (age > (int32) ((MaxTransactionId >> 3) * 3))
  		ereport(WARNING,
  		   (errmsg("database \"%s\" must be vacuumed within %u transactions",
--- 931,940 ----
  	}
  
  	/* Update the wrap limit for GetNewTransactionId */
! 	SetTransactionIdLimit(minXID, &oldest_datname);
  
  	/* Give warning about impending wraparound problems */
! 	age = (int32) (myXID - minXID);
  	if (age > (int32) ((MaxTransactionId >> 3) * 3))
  		ereport(WARNING,
  		   (errmsg("database \"%s\" must be vacuumed within %u transactions",
***************
*** 920,930 ****
  /*
   *	vacuum_rel() -- vacuum one heap relation
   *
-  *		Returns TRUE if we actually processed the relation (or can ignore it
-  *		for some reason), FALSE if we failed to process it due to permissions
-  *		or other reasons.  (A FALSE result really means that some data
-  *		may have been left unvacuumed, so we can't update XID stats.)
-  *
   *		Doing one heap at a time incurs extra overhead, since we need to
   *		check that the heap exists again just before we vacuum it.	The
   *		reason that we do this is so that vacuuming can be spread across
--- 956,961 ----
***************
*** 933,952 ****
   *
   *		At entry and exit, we are not inside a transaction.
   */
! static bool
  vacuum_rel(Oid relid, VacuumStmt *vacstmt, char expected_relkind)
  {
  	LOCKMODE	lmode;
  	Relation	onerel;
  	LockRelId	onerelid;
  	Oid			toast_relid;
- 	bool		result;
  
  	/* Begin a transaction for vacuuming this relation */
  	StartTransactionCommand();
  	/* functions in indexes may want a snapshot set */
  	ActiveSnapshot = CopySnapshot(GetTransactionSnapshot());
  
  	/*
  	 * Tell the cache replacement strategy that vacuum is causing all
  	 * following IO
--- 964,983 ----
   *
   *		At entry and exit, we are not inside a transaction.
   */
! static void
  vacuum_rel(Oid relid, VacuumStmt *vacstmt, char expected_relkind)
  {
  	LOCKMODE	lmode;
  	Relation	onerel;
  	LockRelId	onerelid;
  	Oid			toast_relid;
  
  	/* Begin a transaction for vacuuming this relation */
  	StartTransactionCommand();
  	/* functions in indexes may want a snapshot set */
  	ActiveSnapshot = CopySnapshot(GetTransactionSnapshot());
  
+ 
  	/*
  	 * Tell the cache replacement strategy that vacuum is causing all
  	 * following IO
***************
*** 969,975 ****
  	{
  		StrategyHintVacuum(false);
  		CommitTransactionCommand();
! 		return true;			/* okay 'cause no data there */
  	}
  
  	/*
--- 1000,1006 ----
  	{
  		StrategyHintVacuum(false);
  		CommitTransactionCommand();
! 		return;
  	}
  
  	/*
***************
*** 1000,1006 ****
  		relation_close(onerel, lmode);
  		StrategyHintVacuum(false);
  		CommitTransactionCommand();
! 		return false;
  	}
  
  	/*
--- 1031,1037 ----
  		relation_close(onerel, lmode);
  		StrategyHintVacuum(false);
  		CommitTransactionCommand();
! 		return;
  	}
  
  	/*
***************
*** 1015,1021 ****
  		relation_close(onerel, lmode);
  		StrategyHintVacuum(false);
  		CommitTransactionCommand();
! 		return false;
  	}
  
  	/*
--- 1046,1052 ----
  		relation_close(onerel, lmode);
  		StrategyHintVacuum(false);
  		CommitTransactionCommand();
! 		return;
  	}
  
  	/*
***************
*** 1030,1036 ****
  		relation_close(onerel, lmode);
  		StrategyHintVacuum(false);
  		CommitTransactionCommand();
! 		return true;			/* assume no long-lived data in temp tables */
  	}
  
  	/*
--- 1061,1067 ----
  		relation_close(onerel, lmode);
  		StrategyHintVacuum(false);
  		CommitTransactionCommand();
! 		return;			/* assume no long-lived data in temp tables */
  	}
  
  	/*
***************
*** 1059,1066 ****
  	else
  		lazy_vacuum_rel(onerel, vacstmt);
  
- 	result = true;				/* did the vacuum */
- 
  	/* all done with this class, but hold lock until commit */
  	relation_close(onerel, NoLock);
  
--- 1090,1095 ----
***************
*** 1078,1094 ****
  	 * totally unimportant for toast relations.
  	 */
  	if (toast_relid != InvalidOid)
! 	{
! 		if (!vacuum_rel(toast_relid, vacstmt, RELKIND_TOASTVALUE))
! 			result = false;		/* failed to vacuum the TOAST table? */
! 	}
  
  	/*
  	 * Now release the session-level lock on the master table.
  	 */
  	UnlockRelationForSession(&onerelid, lmode);
  
! 	return result;
  }
  
  
--- 1107,1120 ----
  	 * totally unimportant for toast relations.
  	 */
  	if (toast_relid != InvalidOid)
! 		vacuum_rel(toast_relid, vacstmt, RELKIND_TOASTVALUE);
  
  	/*
  	 * Now release the session-level lock on the master table.
  	 */
  	UnlockRelationForSession(&onerelid, lmode);
  
! 	return;
  }
  
  
***************
*** 1120,1125 ****
--- 1146,1153 ----
  	int			nindexes,
  				i;
  	VRelStats  *vacrelstats;
+ 	TransactionId FreezeLimit,
+ 				  OldestXmin;
  
  	vacuum_set_xid_limits(vacstmt, onerel->rd_rel->relisshared,
  						  &OldestXmin, &FreezeLimit);
***************
*** 1132,1140 ****
  	vacrelstats->rel_tuples = 0;
  	vacrelstats->hasindex = false;
  
  	/* scan the heap */
  	vacuum_pages.num_pages = fraged_pages.num_pages = 0;
! 	scan_heap(vacrelstats, onerel, &vacuum_pages, &fraged_pages);
  
  	/* Now open all indexes of the relation */
  	vac_open_indexes(onerel, AccessExclusiveLock, &nindexes, &Irel);
--- 1160,1180 ----
  	vacrelstats->rel_tuples = 0;
  	vacrelstats->hasindex = false;
  
+ 	/*
+ 	 * Set initial minimum Xid, which will be updated if a smaller Xid is found
+ 	 * in the relation by scan_heap.
+ 	 *
+ 	 * We use RecentXmin here (the minimum Xid that belongs to a transaction
+ 	 * that is still open according to our snapshot), because it is the
+ 	 * earliest transaction that could insert new tuples in the table after our
+ 	 * VACUUM is done.
+ 	 */
+ 	vacrelstats->minxid = RecentXmin;
+ 
  	/* scan the heap */
  	vacuum_pages.num_pages = fraged_pages.num_pages = 0;
! 	scan_heap(vacrelstats, onerel, &vacuum_pages, &fraged_pages, FreezeLimit,
! 			  OldestXmin);
  
  	/* Now open all indexes of the relation */
  	vac_open_indexes(onerel, AccessExclusiveLock, &nindexes, &Irel);
***************
*** 1162,1168 ****
  	{
  		/* Try to shrink heap */
  		repair_frag(vacrelstats, onerel, &vacuum_pages, &fraged_pages,
! 					nindexes, Irel);
  		vac_close_indexes(nindexes, Irel, NoLock);
  	}
  	else
--- 1202,1208 ----
  	{
  		/* Try to shrink heap */
  		repair_frag(vacrelstats, onerel, &vacuum_pages, &fraged_pages,
! 					nindexes, Irel, OldestXmin);
  		vac_close_indexes(nindexes, Irel, NoLock);
  	}
  	else
***************
*** 1180,1186 ****
  
  	/* update statistics in pg_class */
  	vac_update_relstats(RelationGetRelid(onerel), vacrelstats->rel_pages,
! 						vacrelstats->rel_tuples, vacrelstats->hasindex);
  
  	/* report results to the stats collector, too */
  	pgstat_report_vacuum(RelationGetRelid(onerel), onerel->rd_rel->relisshared,
--- 1220,1227 ----
  
  	/* update statistics in pg_class */
  	vac_update_relstats(RelationGetRelid(onerel), vacrelstats->rel_pages,
! 						vacrelstats->rel_tuples, vacrelstats->hasindex,
! 						vacrelstats->minxid, OldestXmin);
  
  	/* report results to the stats collector, too */
  	pgstat_report_vacuum(RelationGetRelid(onerel), onerel->rd_rel->relisshared,
***************
*** 1196,1209 ****
   *		deleted tuples), constructs fraged_pages (list of pages with free
   *		space that tuples could be moved into), and calculates statistics
   *		on the number of live tuples in the heap.
   */
  static void
  scan_heap(VRelStats *vacrelstats, Relation onerel,
! 		  VacPageList vacuum_pages, VacPageList fraged_pages)
  {
  	BlockNumber nblocks,
  				blkno;
- 	HeapTupleData tuple;
  	char	   *relname;
  	VacPage		vacpage;
  	BlockNumber empty_pages,
--- 1237,1253 ----
   *		deleted tuples), constructs fraged_pages (list of pages with free
   *		space that tuples could be moved into), and calculates statistics
   *		on the number of live tuples in the heap.
+  *
+  *		It also updates the minimum Xid found anywhere on the table in
+  *		vacrelstats->minxid, for later storing it in pg_class.relminxid.
   */
  static void
  scan_heap(VRelStats *vacrelstats, Relation onerel,
! 		  VacPageList vacuum_pages, VacPageList fraged_pages,
! 		  TransactionId FreezeLimit, TransactionId OldestXmin)
  {
  	BlockNumber nblocks,
  				blkno;
  	char	   *relname;
  	VacPage		vacpage;
  	BlockNumber empty_pages,
***************
*** 1317,1322 ****
--- 1361,1367 ----
  		{
  			ItemId		itemid = PageGetItemId(page, offnum);
  			bool		tupgone = false;
+ 			HeapTupleData tuple;
  
  			/*
  			 * Collect un-used items too - it's possible to have indexes
***************
*** 1452,1463 ****
--- 1497,1519 ----
  			}
  			else
  			{
+ 				TransactionId	min;
+ 
  				num_tuples += 1;
  				notup = false;
  				if (tuple.t_len < min_tlen)
  					min_tlen = tuple.t_len;
  				if (tuple.t_len > max_tlen)
  					max_tlen = tuple.t_len;
+ 
+ 				/* 
+ 				 * If the tuple is alive, we consider it for the "minxid"
+ 				 * calculations.
+ 				 */
+ 				min = vactuple_get_minxid(&tuple);
+ 				if (TransactionIdIsValid(min) &&
+ 					TransactionIdPrecedes(min, vacrelstats->minxid))
+ 					vacrelstats->minxid = min;
  			}
  		}						/* scan along page */
  
***************
*** 1583,1588 ****
--- 1639,1701 ----
  					   pg_rusage_show(&ru0))));
  }
  
+ /*
+  * vactuple_get_minxid
+  *
+  * Get the minimum relevant Xid for a tuple, not considering FrozenXid.
+  * Return InvalidXid if none (i.e., xmin=FrozenXid, xmax=InvalidXid).
+  * This is for the purpose of calculating pg_class.relminxid for a table
+  * we're vacuuming.
+  */
+ TransactionId
+ vactuple_get_minxid(HeapTuple tuple)
+ {
+ 	TransactionId	min = InvalidTransactionId;
+ 
+ 	/* 
+ 	 * Initialize calculations with Xmin.  NB -- may be FrozenXid and
+ 	 * we don't want that one.
+ 	 */
+ 	if (TransactionIdIsNormal(HeapTupleHeaderGetXmin(tuple->t_data)))
+ 		min = HeapTupleHeaderGetXmin(tuple->t_data);
+ 
+ 	/*
+ 	 * If Xmax is not marked INVALID, we assume it's valid without making
+ 	 * further checks on it --- it must be recently obsoleted or still running,
+ 	 * else HeapTupleSatisfiesVacuum would have deemed it removable.
+ 	 */
+ 	if (!(tuple->t_data->t_infomask | HEAP_XMAX_INVALID))
+ 	{
+ 		TransactionId	 xmax = HeapTupleHeaderGetXmax(tuple->t_data);
+ 
+ 		/* If xmax is a plain Xid, consider it by itself */
+ 		if (!(tuple->t_data->t_infomask | HEAP_XMAX_IS_MULTI))
+ 		{
+ 			if (!TransactionIdIsValid(min) ||
+ 				(TransactionIdIsNormal(xmax) &&
+ 				 TransactionIdPrecedes(xmax, min)))
+ 				min = xmax;
+ 		}
+ 		else
+ 		{
+ 			/* If it's a MultiXactId, consider each of its members */
+ 			TransactionId *members;
+ 			int			nmembers,
+ 						membno;
+ 
+ 			nmembers = GetMultiXactIdMembers(xmax, &members);
+ 
+ 			for (membno = 0; membno < nmembers; membno++)
+ 			{
+ 				if (!TransactionIdIsValid(min) ||
+ 					TransactionIdPrecedes(members[membno], min))
+ 					min = members[membno];
+ 			}
+ 		}
+ 	}
+ 
+ 	return min;
+ }
  
  /*
   *	repair_frag() -- try to repair relation's fragmentation
***************
*** 1597,1603 ****
  static void
  repair_frag(VRelStats *vacrelstats, Relation onerel,
  			VacPageList vacuum_pages, VacPageList fraged_pages,
! 			int nindexes, Relation *Irel)
  {
  	TransactionId myXID = GetCurrentTransactionId();
  	Buffer		dst_buffer = InvalidBuffer;
--- 1710,1716 ----
  static void
  repair_frag(VRelStats *vacrelstats, Relation onerel,
  			VacPageList vacuum_pages, VacPageList fraged_pages,
! 			int nindexes, Relation *Irel, TransactionId OldestXmin)
  {
  	TransactionId myXID = GetCurrentTransactionId();
  	Buffer		dst_buffer = InvalidBuffer;
***************
*** 2940,2946 ****
  	/* now update statistics in pg_class */
  	vac_update_relstats(RelationGetRelid(indrel),
  						stats->num_pages, stats->num_index_tuples,
! 						false);
  
  	ereport(elevel,
  			(errmsg("index \"%s\" now contains %.0f row versions in %u pages",
--- 3053,3059 ----
  	/* now update statistics in pg_class */
  	vac_update_relstats(RelationGetRelid(indrel),
  						stats->num_pages, stats->num_index_tuples,
! 						false, InvalidTransactionId, InvalidTransactionId);
  
  	ereport(elevel,
  			(errmsg("index \"%s\" now contains %.0f row versions in %u pages",
***************
*** 3009,3015 ****
  	/* now update statistics in pg_class */
  	vac_update_relstats(RelationGetRelid(indrel),
  						stats->num_pages, stats->num_index_tuples,
! 						false);
  
  	ereport(elevel,
  			(errmsg("index \"%s\" now contains %.0f row versions in %u pages",
--- 3122,3128 ----
  	/* now update statistics in pg_class */
  	vac_update_relstats(RelationGetRelid(indrel),
  						stats->num_pages, stats->num_index_tuples,
! 						false, InvalidTransactionId, InvalidTransactionId);
  
  	ereport(elevel,
  			(errmsg("index \"%s\" now contains %.0f row versions in %u pages",
Index: src/backend/commands/vacuumlazy.c
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/commands/vacuumlazy.c,v
retrieving revision 1.70
diff -c -r1.70 vacuumlazy.c
*** src/backend/commands/vacuumlazy.c	2 May 2006 22:25:10 -0000	1.70
--- src/backend/commands/vacuumlazy.c	28 Jun 2006 21:43:37 -0000
***************
*** 42,47 ****
--- 42,48 ----
  #include "access/genam.h"
  #include "access/heapam.h"
  #include "access/xlog.h"
+ #include "catalog/catalog.h"
  #include "commands/vacuum.h"
  #include "miscadmin.h"
  #include "pgstat.h"
***************
*** 72,77 ****
--- 73,79 ----
  	double		tuples_deleted;
  	BlockNumber nonempty_pages; /* actually, last nonempty page + 1 */
  	Size		threshold;		/* minimum interesting free space */
+ 	TransactionId minxid;		/* minimum Xid present anywhere in table */
  	/* List of TIDs of tuples we intend to delete */
  	/* NB: this list is ordered by TID address */
  	int			num_dead_tuples;	/* current # of entries */
***************
*** 88,100 ****
  
  static int	elevel = -1;
  
- static TransactionId OldestXmin;
- static TransactionId FreezeLimit;
- 
  
  /* non-export function prototypes */
  static void lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
! 			   Relation *Irel, int nindexes);
  static void lazy_vacuum_heap(Relation onerel, LVRelStats *vacrelstats);
  static void lazy_vacuum_index(Relation indrel,
  							  IndexBulkDeleteResult **stats,
--- 90,100 ----
  
  static int	elevel = -1;
  
  
  /* non-export function prototypes */
  static void lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
! 			   Relation *Irel, int nindexes, TransactionId FreezeLimit,
! 			   TransactionId OldestXmin);
  static void lazy_vacuum_heap(Relation onerel, LVRelStats *vacrelstats);
  static void lazy_vacuum_index(Relation indrel,
  							  IndexBulkDeleteResult **stats,
***************
*** 104,112 ****
  							   LVRelStats *vacrelstats);
  static int lazy_vacuum_page(Relation onerel, BlockNumber blkno, Buffer buffer,
  				 int tupindex, LVRelStats *vacrelstats);
! static void lazy_truncate_heap(Relation onerel, LVRelStats *vacrelstats);
  static BlockNumber count_nondeletable_pages(Relation onerel,
! 						 LVRelStats *vacrelstats);
  static void lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks);
  static void lazy_record_dead_tuple(LVRelStats *vacrelstats,
  					   ItemPointer itemptr);
--- 104,113 ----
  							   LVRelStats *vacrelstats);
  static int lazy_vacuum_page(Relation onerel, BlockNumber blkno, Buffer buffer,
  				 int tupindex, LVRelStats *vacrelstats);
! static void lazy_truncate_heap(Relation onerel, LVRelStats *vacrelstats,
! 							   TransactionId OldestXmin);
  static BlockNumber count_nondeletable_pages(Relation onerel,
! 						 LVRelStats *vacrelstats, TransactionId OldestXmin);
  static void lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks);
  static void lazy_record_dead_tuple(LVRelStats *vacrelstats,
  					   ItemPointer itemptr);
***************
*** 122,128 ****
   *	lazy_vacuum_rel() -- perform LAZY VACUUM for one heap relation
   *
   *		This routine vacuums a single heap, cleans out its indexes, and
!  *		updates its num_pages and num_tuples statistics.
   *
   *		At entry, we have already established a transaction and opened
   *		and locked the relation.
--- 123,130 ----
   *	lazy_vacuum_rel() -- perform LAZY VACUUM for one heap relation
   *
   *		This routine vacuums a single heap, cleans out its indexes, and
!  *		updates its relpages and reltuples statistics, as well as the
!  *		relminxid and relvacuumxid information.
   *
   *		At entry, we have already established a transaction and opened
   *		and locked the relation.
***************
*** 135,140 ****
--- 137,144 ----
  	int			nindexes;
  	bool		hasindex;
  	BlockNumber possibly_freeable;
+ 	TransactionId OldestXmin,
+ 				  FreezeLimit;
  
  	if (vacstmt->verbose)
  		elevel = INFO;
***************
*** 150,161 ****
  	/* XXX should we scale it up or down?  Adjust vacuum.c too, if so */
  	vacrelstats->threshold = GetAvgFSMRequestSize(&onerel->rd_node);
  
  	/* Open all indexes of the relation */
  	vac_open_indexes(onerel, ShareUpdateExclusiveLock, &nindexes, &Irel);
  	hasindex = (nindexes > 0);
  
  	/* Do the vacuuming */
! 	lazy_scan_heap(onerel, vacrelstats, Irel, nindexes);
  
  	/* Done with indexes */
  	vac_close_indexes(nindexes, Irel, NoLock);
--- 154,176 ----
  	/* XXX should we scale it up or down?  Adjust vacuum.c too, if so */
  	vacrelstats->threshold = GetAvgFSMRequestSize(&onerel->rd_node);
  
+ 	/*
+ 	 * Set initial minimum Xid, which will be updated if a smaller Xid is found
+ 	 * in the relation by lazy_scan_heap.
+ 	 *
+ 	 * We use RecentXmin here (the minimum Xid that belongs to a transaction
+ 	 * that is still open according to our snapshot), because it is the
+ 	 * earliest transaction that could concurrently insert new tuples in the
+ 	 * table.
+ 	 */
+ 	vacrelstats->minxid = RecentXmin;
+ 
  	/* Open all indexes of the relation */
  	vac_open_indexes(onerel, ShareUpdateExclusiveLock, &nindexes, &Irel);
  	hasindex = (nindexes > 0);
  
  	/* Do the vacuuming */
! 	lazy_scan_heap(onerel, vacrelstats, Irel, nindexes, FreezeLimit, OldestXmin);
  
  	/* Done with indexes */
  	vac_close_indexes(nindexes, Irel, NoLock);
***************
*** 169,184 ****
  	possibly_freeable = vacrelstats->rel_pages - vacrelstats->nonempty_pages;
  	if (possibly_freeable >= REL_TRUNCATE_MINIMUM ||
  		possibly_freeable >= vacrelstats->rel_pages / REL_TRUNCATE_FRACTION)
! 		lazy_truncate_heap(onerel, vacrelstats);
  
  	/* Update shared free space map with final free space info */
  	lazy_update_fsm(onerel, vacrelstats);
  
  	/* Update statistics in pg_class */
! 	vac_update_relstats(RelationGetRelid(onerel),
! 						vacrelstats->rel_pages,
! 						vacrelstats->rel_tuples,
! 						hasindex);
  
  	/* report results to the stats collector, too */
  	pgstat_report_vacuum(RelationGetRelid(onerel), onerel->rd_rel->relisshared,
--- 184,198 ----
  	possibly_freeable = vacrelstats->rel_pages - vacrelstats->nonempty_pages;
  	if (possibly_freeable >= REL_TRUNCATE_MINIMUM ||
  		possibly_freeable >= vacrelstats->rel_pages / REL_TRUNCATE_FRACTION)
! 		lazy_truncate_heap(onerel, vacrelstats, OldestXmin);
  
  	/* Update shared free space map with final free space info */
  	lazy_update_fsm(onerel, vacrelstats);
  
  	/* Update statistics in pg_class */
! 	vac_update_relstats(RelationGetRelid(onerel), vacrelstats->rel_pages,
! 						vacrelstats->rel_tuples, hasindex,
! 						vacrelstats->minxid, OldestXmin);
  
  	/* report results to the stats collector, too */
  	pgstat_report_vacuum(RelationGetRelid(onerel), onerel->rd_rel->relisshared,
***************
*** 193,202 ****
   *		and pages with free space, and calculates statistics on the number
   *		of live tuples in the heap.  When done, or when we run low on space
   *		for dead-tuple TIDs, invoke vacuuming of indexes and heap.
   */
  static void
  lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
! 			   Relation *Irel, int nindexes)
  {
  	BlockNumber nblocks,
  				blkno;
--- 207,220 ----
   *		and pages with free space, and calculates statistics on the number
   *		of live tuples in the heap.  When done, or when we run low on space
   *		for dead-tuple TIDs, invoke vacuuming of indexes and heap.
+  *
+  *		It also updates the minimum Xid found anywhere on the table in
+  *		vacrelstats->minxid, for later storing it in pg_class.relminxid.
   */
  static void
  lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
! 			   Relation *Irel, int nindexes, TransactionId FreezeLimit,
! 			   TransactionId OldestXmin)
  {
  	BlockNumber nblocks,
  				blkno;
***************
*** 406,413 ****
--- 424,442 ----
  			}
  			else
  			{
+ 				TransactionId min;
+ 
  				num_tuples += 1;
  				hastup = true;
+ 
+ 				/* 
+ 				 * If the tuple is alive, we consider it for the "minxid"
+ 				 * calculations.
+ 				 */
+ 				min = vactuple_get_minxid(&tuple);
+ 				if (TransactionIdIsValid(min) &&
+ 					TransactionIdPrecedes(min, vacrelstats->minxid))
+ 					vacrelstats->minxid = min;
  			}
  		}						/* scan along page */
  
***************
*** 668,676 ****
  
  	/* now update statistics in pg_class */
  	vac_update_relstats(RelationGetRelid(indrel),
! 						stats->num_pages,
! 						stats->num_index_tuples,
! 						false);
  
  	ereport(elevel,
  			(errmsg("index \"%s\" now contains %.0f row versions in %u pages",
--- 697,704 ----
  
  	/* now update statistics in pg_class */
  	vac_update_relstats(RelationGetRelid(indrel),
! 						stats->num_pages, stats->num_index_tuples,
! 						false, InvalidTransactionId, InvalidTransactionId);
  
  	ereport(elevel,
  			(errmsg("index \"%s\" now contains %.0f row versions in %u pages",
***************
*** 691,697 ****
   * lazy_truncate_heap - try to truncate off any empty pages at the end
   */
  static void
! lazy_truncate_heap(Relation onerel, LVRelStats *vacrelstats)
  {
  	BlockNumber old_rel_pages = vacrelstats->rel_pages;
  	BlockNumber new_rel_pages;
--- 719,726 ----
   * lazy_truncate_heap - try to truncate off any empty pages at the end
   */
  static void
! lazy_truncate_heap(Relation onerel, LVRelStats *vacrelstats,
! 				   TransactionId OldestXmin)
  {
  	BlockNumber old_rel_pages = vacrelstats->rel_pages;
  	BlockNumber new_rel_pages;
***************
*** 732,738 ****
  	 * because other backends could have added tuples to these pages whilst we
  	 * were vacuuming.
  	 */
! 	new_rel_pages = count_nondeletable_pages(onerel, vacrelstats);
  
  	if (new_rel_pages >= old_rel_pages)
  	{
--- 761,767 ----
  	 * because other backends could have added tuples to these pages whilst we
  	 * were vacuuming.
  	 */
! 	new_rel_pages = count_nondeletable_pages(onerel, vacrelstats, OldestXmin);
  
  	if (new_rel_pages >= old_rel_pages)
  	{
***************
*** 787,793 ****
   * Returns number of nondeletable pages (last nonempty page + 1).
   */
  static BlockNumber
! count_nondeletable_pages(Relation onerel, LVRelStats *vacrelstats)
  {
  	BlockNumber blkno;
  	HeapTupleData tuple;
--- 816,823 ----
   * Returns number of nondeletable pages (last nonempty page + 1).
   */
  static BlockNumber
! count_nondeletable_pages(Relation onerel, LVRelStats *vacrelstats,
! 						 TransactionId OldestXmin)
  {
  	BlockNumber blkno;
  	HeapTupleData tuple;
Index: src/backend/libpq/hba.c
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/libpq/hba.c,v
retrieving revision 1.151
diff -c -r1.151 hba.c
*** src/backend/libpq/hba.c	6 Mar 2006 17:41:43 -0000	1.151
--- src/backend/libpq/hba.c	28 Jun 2006 18:02:59 -0000
***************
*** 1005,1011 ****
   *	dbname: gets database name (must be of size NAMEDATALEN bytes)
   *	dboid: gets database OID
   *	dbtablespace: gets database's default tablespace's OID
!  *	dbfrozenxid: gets database's frozen XID
   *	dbvacuumxid: gets database's vacuum XID
   *
   * This is not much related to the other functions in hba.c, but we put it
--- 1005,1011 ----
   *	dbname: gets database name (must be of size NAMEDATALEN bytes)
   *	dboid: gets database OID
   *	dbtablespace: gets database's default tablespace's OID
!  *	dbminxid: gets database's minimum XID
   *	dbvacuumxid: gets database's vacuum XID
   *
   * This is not much related to the other functions in hba.c, but we put it
***************
*** 1013,1019 ****
   */
  bool
  read_pg_database_line(FILE *fp, char *dbname, Oid *dboid,
! 					  Oid *dbtablespace, TransactionId *dbfrozenxid,
  					  TransactionId *dbvacuumxid)
  {
  	char		buf[MAX_TOKEN];
--- 1013,1019 ----
   */
  bool
  read_pg_database_line(FILE *fp, char *dbname, Oid *dboid,
! 					  Oid *dbtablespace, TransactionId *dbminxid,
  					  TransactionId *dbvacuumxid)
  {
  	char		buf[MAX_TOKEN];
***************
*** 1036,1042 ****
  	next_token(fp, buf, sizeof(buf));
  	if (!isdigit((unsigned char) buf[0]))
  		elog(FATAL, "bad data in flat pg_database file");
! 	*dbfrozenxid = atoxid(buf);
  	next_token(fp, buf, sizeof(buf));
  	if (!isdigit((unsigned char) buf[0]))
  		elog(FATAL, "bad data in flat pg_database file");
--- 1036,1042 ----
  	next_token(fp, buf, sizeof(buf));
  	if (!isdigit((unsigned char) buf[0]))
  		elog(FATAL, "bad data in flat pg_database file");
! 	*dbminxid = atoxid(buf);
  	next_token(fp, buf, sizeof(buf));
  	if (!isdigit((unsigned char) buf[0]))
  		elog(FATAL, "bad data in flat pg_database file");
Index: src/backend/postmaster/autovacuum.c
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/postmaster/autovacuum.c,v
retrieving revision 1.19
diff -c -r1.19 autovacuum.c
*** src/backend/postmaster/autovacuum.c	19 May 2006 15:15:37 -0000	1.19
--- src/backend/postmaster/autovacuum.c	28 Jun 2006 18:02:59 -0000
***************
*** 79,85 ****
  {
  	Oid			oid;
  	char	   *name;
! 	TransactionId frozenxid;
  	TransactionId vacuumxid;
  	PgStat_StatDBEntry *entry;
  	int32		age;
--- 79,85 ----
  {
  	Oid			oid;
  	char	   *name;
! 	TransactionId minxid;
  	TransactionId vacuumxid;
  	PgStat_StatDBEntry *entry;
  	int32		age;
***************
*** 349,355 ****
  	{
  		autovac_dbase *tmp = lfirst(cell);
  		bool		this_whole_db;
! 		int32		freeze_age,
  					vacuum_age;
  
  		/*
--- 349,355 ----
  	{
  		autovac_dbase *tmp = lfirst(cell);
  		bool		this_whole_db;
! 		int32		true_age,
  					vacuum_age;
  
  		/*
***************
*** 362,370 ****
  		 * Unlike vacuum.c, we also look at vacuumxid.	This is so that
  		 * pg_clog can be kept trimmed to a reasonable size.
  		 */
! 		freeze_age = (int32) (nextXid - tmp->frozenxid);
  		vacuum_age = (int32) (nextXid - tmp->vacuumxid);
! 		tmp->age = Max(freeze_age, vacuum_age);
  
  		this_whole_db = (tmp->age >
  						 (int32) ((MaxTransactionId >> 3) * 3 - 100000));
--- 362,370 ----
  		 * Unlike vacuum.c, we also look at vacuumxid.	This is so that
  		 * pg_clog can be kept trimmed to a reasonable size.
  		 */
! 		true_age = (int32) (nextXid - tmp->minxid);
  		vacuum_age = (int32) (nextXid - tmp->vacuumxid);
! 		tmp->age = Max(true_age, vacuum_age);
  
  		this_whole_db = (tmp->age >
  						 (int32) ((MaxTransactionId >> 3) * 3 - 100000));
***************
*** 455,461 ****
  	FILE	   *db_file;
  	Oid			db_id;
  	Oid			db_tablespace;
! 	TransactionId db_frozenxid;
  	TransactionId db_vacuumxid;
  
  	filename = database_getflatfilename();
--- 455,461 ----
  	FILE	   *db_file;
  	Oid			db_id;
  	Oid			db_tablespace;
! 	TransactionId db_minxid;
  	TransactionId db_vacuumxid;
  
  	filename = database_getflatfilename();
***************
*** 466,472 ****
  				 errmsg("could not open file \"%s\": %m", filename)));
  
  	while (read_pg_database_line(db_file, thisname, &db_id,
! 								 &db_tablespace, &db_frozenxid,
  								 &db_vacuumxid))
  	{
  		autovac_dbase *db;
--- 466,472 ----
  				 errmsg("could not open file \"%s\": %m", filename)));
  
  	while (read_pg_database_line(db_file, thisname, &db_id,
! 								 &db_tablespace, &db_minxid,
  								 &db_vacuumxid))
  	{
  		autovac_dbase *db;
***************
*** 475,481 ****
  
  		db->oid = db_id;
  		db->name = pstrdup(thisname);
! 		db->frozenxid = db_frozenxid;
  		db->vacuumxid = db_vacuumxid;
  		/* these get set later: */
  		db->entry = NULL;
--- 475,481 ----
  
  		db->oid = db_id;
  		db->name = pstrdup(thisname);
! 		db->minxid = db_minxid;
  		db->vacuumxid = db_vacuumxid;
  		/* these get set later: */
  		db->entry = NULL;
Index: src/backend/utils/init/flatfiles.c
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/backend/utils/init/flatfiles.c,v
retrieving revision 1.18
diff -c -r1.18 flatfiles.c
*** src/backend/utils/init/flatfiles.c	4 May 2006 16:07:29 -0000	1.18
--- src/backend/utils/init/flatfiles.c	28 Jun 2006 18:02:59 -0000
***************
*** 163,169 ****
  /*
   * write_database_file: update the flat database file
   *
!  * A side effect is to determine the oldest database's datfrozenxid
   * so we can set or update the XID wrap limit.
   */
  static void
--- 163,169 ----
  /*
   * write_database_file: update the flat database file
   *
!  * A side effect is to determine the oldest database's datminxid
   * so we can set or update the XID wrap limit.
   */
  static void
***************
*** 177,183 ****
  	HeapScanDesc scan;
  	HeapTuple	tuple;
  	NameData	oldest_datname;
! 	TransactionId oldest_datfrozenxid = InvalidTransactionId;
  
  	/*
  	 * Create a temporary filename to be renamed later.  This prevents the
--- 177,183 ----
  	HeapScanDesc scan;
  	HeapTuple	tuple;
  	NameData	oldest_datname;
! 	TransactionId oldest_datminxid = InvalidTransactionId;
  
  	/*
  	 * Create a temporary filename to be renamed later.  This prevents the
***************
*** 208,234 ****
  		char	   *datname;
  		Oid			datoid;
  		Oid			dattablespace;
! 		TransactionId datfrozenxid,
  					datvacuumxid;
  
  		datname = NameStr(dbform->datname);
  		datoid = HeapTupleGetOid(tuple);
  		dattablespace = dbform->dattablespace;
! 		datfrozenxid = dbform->datfrozenxid;
  		datvacuumxid = dbform->datvacuumxid;
  
  		/*
! 		 * Identify the oldest datfrozenxid, ignoring databases that are not
  		 * connectable (we assume they are safely frozen).	This must match
  		 * the logic in vac_truncate_clog() in vacuum.c.
  		 */
  		if (dbform->datallowconn &&
! 			TransactionIdIsNormal(datfrozenxid))
  		{
! 			if (oldest_datfrozenxid == InvalidTransactionId ||
! 				TransactionIdPrecedes(datfrozenxid, oldest_datfrozenxid))
  			{
! 				oldest_datfrozenxid = datfrozenxid;
  				namestrcpy(&oldest_datname, datname);
  			}
  		}
--- 208,234 ----
  		char	   *datname;
  		Oid			datoid;
  		Oid			dattablespace;
! 		TransactionId datminxid,
  					datvacuumxid;
  
  		datname = NameStr(dbform->datname);
  		datoid = HeapTupleGetOid(tuple);
  		dattablespace = dbform->dattablespace;
! 		datminxid = dbform->datminxid;
  		datvacuumxid = dbform->datvacuumxid;
  
  		/*
! 		 * Identify the oldest datminxid, ignoring databases that are not
  		 * connectable (we assume they are safely frozen).	This must match
  		 * the logic in vac_truncate_clog() in vacuum.c.
  		 */
  		if (dbform->datallowconn &&
! 			TransactionIdIsNormal(datminxid))
  		{
! 			if (oldest_datminxid == InvalidTransactionId ||
! 				TransactionIdPrecedes(datminxid, oldest_datminxid))
  			{
! 				oldest_datminxid = datminxid;
  				namestrcpy(&oldest_datname, datname);
  			}
  		}
***************
*** 244,257 ****
  		}
  
  		/*
! 		 * The file format is: "dbname" oid tablespace frozenxid vacuumxid
  		 *
  		 * The xids are not needed for backend startup, but are of use to
  		 * autovacuum, and might also be helpful for forensic purposes.
  		 */
  		fputs_quote(datname, fp);
  		fprintf(fp, " %u %u %u %u\n",
! 				datoid, dattablespace, datfrozenxid, datvacuumxid);
  	}
  	heap_endscan(scan);
  
--- 244,257 ----
  		}
  
  		/*
! 		 * The file format is: "dbname" oid tablespace minxid vacuumxid
  		 *
  		 * The xids are not needed for backend startup, but are of use to
  		 * autovacuum, and might also be helpful for forensic purposes.
  		 */
  		fputs_quote(datname, fp);
  		fprintf(fp, " %u %u %u %u\n",
! 				datoid, dattablespace, datminxid, datvacuumxid);
  	}
  	heap_endscan(scan);
  
***************
*** 272,281 ****
  						tempname, filename)));
  
  	/*
! 	 * Set the transaction ID wrap limit using the oldest datfrozenxid
  	 */
! 	if (oldest_datfrozenxid != InvalidTransactionId)
! 		SetTransactionIdLimit(oldest_datfrozenxid, &oldest_datname);
  }
  
  
--- 272,281 ----
  						tempname, filename)));
  
  	/*
! 	 * Set the transaction ID wrap limit using the oldest datminxid
  	 */
! 	if (oldest_datminxid != InvalidTransactionId)
! 		SetTransactionIdLimit(oldest_datminxid, &oldest_datname);
  }
  
  
Index: src/include/access/transam.h
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/include/access/transam.h,v
retrieving revision 1.57
diff -c -r1.57 transam.h
*** src/include/access/transam.h	5 Mar 2006 15:58:53 -0000	1.57
--- src/include/access/transam.h	28 Jun 2006 21:49:51 -0000
***************
*** 23,28 ****
--- 23,29 ----
   * always be considered valid.
   *
   * FirstNormalTransactionId is the first "normal" transaction id.
+  * Note: if you need to change it, you must change it in pg_class.h as well.
   * ----------------
   */
  #define InvalidTransactionId		((TransactionId) 0)
***************
*** 123,129 ****
  /* in transam/varsup.c */
  extern TransactionId GetNewTransactionId(bool isSubXact);
  extern TransactionId ReadNewTransactionId(void);
! extern void SetTransactionIdLimit(TransactionId oldest_datfrozenxid,
  					  Name oldest_datname);
  extern Oid	GetNewObjectId(void);
  
--- 124,130 ----
  /* in transam/varsup.c */
  extern TransactionId GetNewTransactionId(bool isSubXact);
  extern TransactionId ReadNewTransactionId(void);
! extern void SetTransactionIdLimit(TransactionId oldest_datminxid,
  					  Name oldest_datname);
  extern Oid	GetNewObjectId(void);
  
Index: src/include/catalog/pg_attribute.h
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/include/catalog/pg_attribute.h,v
retrieving revision 1.120
diff -c -r1.120 pg_attribute.h
*** src/include/catalog/pg_attribute.h	5 Mar 2006 15:58:54 -0000	1.120
--- src/include/catalog/pg_attribute.h	28 Jun 2006 18:02:59 -0000
***************
*** 404,410 ****
  { 1259, {"relhaspkey"},    16, -1,	1, 22, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
  { 1259, {"relhasrules"},   16, -1,	1, 23, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
  { 1259, {"relhassubclass"},16, -1,	1, 24, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
! { 1259, {"relacl"},		 1034, -1, -1, 25, 1, -1, -1, false, 'x', 'i', false, false, false, true, 0 }
  
  DATA(insert ( 1259 relname			19 -1 NAMEDATALEN	1 0 -1 -1 f p i t f f t 0));
  DATA(insert ( 1259 relnamespace		26 -1 4   2 0 -1 -1 t p i t f f t 0));
--- 404,412 ----
  { 1259, {"relhaspkey"},    16, -1,	1, 22, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
  { 1259, {"relhasrules"},   16, -1,	1, 23, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
  { 1259, {"relhassubclass"},16, -1,	1, 24, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
! { 1259, {"relminxid"},     28, -1,	4, 25, 0, -1, -1, true, 'p', 'i', true, false, false, true, 0 }, \
! { 1259, {"relvacuumxid"},  28, -1,	4, 26, 0, -1, -1, true, 'p', 'i', true, false, false, true, 0 }, \
! { 1259, {"relacl"},		 1034, -1, -1, 27, 1, -1, -1, false, 'x', 'i', false, false, false, true, 0 }
  
  DATA(insert ( 1259 relname			19 -1 NAMEDATALEN	1 0 -1 -1 f p i t f f t 0));
  DATA(insert ( 1259 relnamespace		26 -1 4   2 0 -1 -1 t p i t f f t 0));
***************
*** 430,436 ****
  DATA(insert ( 1259 relhaspkey		16 -1 1  22 0 -1 -1 t p c t f f t 0));
  DATA(insert ( 1259 relhasrules		16 -1 1  23 0 -1 -1 t p c t f f t 0));
  DATA(insert ( 1259 relhassubclass	16 -1 1  24 0 -1 -1 t p c t f f t 0));
! DATA(insert ( 1259 relacl		  1034 -1 -1 25 1 -1 -1 f x i f f f t 0));
  DATA(insert ( 1259 ctid				27 0  6  -1 0 -1 -1 f p s t f f t 0));
  DATA(insert ( 1259 oid				26 0  4  -2 0 -1 -1 t p i t f f t 0));
  DATA(insert ( 1259 xmin				28 0  4  -3 0 -1 -1 t p i t f f t 0));
--- 432,440 ----
  DATA(insert ( 1259 relhaspkey		16 -1 1  22 0 -1 -1 t p c t f f t 0));
  DATA(insert ( 1259 relhasrules		16 -1 1  23 0 -1 -1 t p c t f f t 0));
  DATA(insert ( 1259 relhassubclass	16 -1 1  24 0 -1 -1 t p c t f f t 0));
! DATA(insert ( 1259 relminxid		28 -1 4  25 0 -1 -1 t p i t f f t 0));
! DATA(insert ( 1259 relvacuumxid		28 -1 4  26 0 -1 -1 t p i t f f t 0));
! DATA(insert ( 1259 relacl		  1034 -1 -1 27 1 -1 -1 f x i f f f t 0));
  DATA(insert ( 1259 ctid				27 0  6  -1 0 -1 -1 f p s t f f t 0));
  DATA(insert ( 1259 oid				26 0  4  -2 0 -1 -1 t p i t f f t 0));
  DATA(insert ( 1259 xmin				28 0  4  -3 0 -1 -1 t p i t f f t 0));
Index: src/include/catalog/pg_class.h
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/include/catalog/pg_class.h,v
retrieving revision 1.92
diff -c -r1.92 pg_class.h
*** src/include/catalog/pg_class.h	28 May 2006 02:27:08 -0000	1.92
--- src/include/catalog/pg_class.h	28 Jun 2006 21:49:26 -0000
***************
*** 74,79 ****
--- 74,81 ----
  	bool		relhaspkey;		/* has PRIMARY KEY index */
  	bool		relhasrules;	/* has associated rules */
  	bool		relhassubclass; /* has derived classes */
+ 	TransactionId relminxid;	/* minimum Xid present in table */
+ 	TransactionId relvacuumxid;	/* Xid used as last vacuum OldestXmin */
  
  	/*
  	 * relacl may or may not be present, see note above!
***************
*** 83,89 ****
  
  /* Size of fixed part of pg_class tuples, not counting relacl or padding */
  #define CLASS_TUPLE_SIZE \
! 	 (offsetof(FormData_pg_class,relhassubclass) + sizeof(bool))
  
  /* ----------------
   *		Form_pg_class corresponds to a pointer to a tuple with
--- 85,91 ----
  
  /* Size of fixed part of pg_class tuples, not counting relacl or padding */
  #define CLASS_TUPLE_SIZE \
! 	 (offsetof(FormData_pg_class,relvacuumxid) + sizeof(TransactionId))
  
  /* ----------------
   *		Form_pg_class corresponds to a pointer to a tuple with
***************
*** 103,110 ****
   *		relacl field.  This is a kluge.
   * ----------------
   */
! #define Natts_pg_class_fixed			24
! #define Natts_pg_class					25
  #define Anum_pg_class_relname			1
  #define Anum_pg_class_relnamespace		2
  #define Anum_pg_class_reltype			3
--- 105,112 ----
   *		relacl field.  This is a kluge.
   * ----------------
   */
! #define Natts_pg_class_fixed			26
! #define Natts_pg_class					27
  #define Anum_pg_class_relname			1
  #define Anum_pg_class_relnamespace		2
  #define Anum_pg_class_reltype			3
***************
*** 129,135 ****
  #define Anum_pg_class_relhaspkey		22
  #define Anum_pg_class_relhasrules		23
  #define Anum_pg_class_relhassubclass	24
! #define Anum_pg_class_relacl			25
  
  /* ----------------
   *		initial contents of pg_class
--- 131,139 ----
  #define Anum_pg_class_relhaspkey		22
  #define Anum_pg_class_relhasrules		23
  #define Anum_pg_class_relhassubclass	24
! #define Anum_pg_class_relminxid			25
! #define Anum_pg_class_relvacuumxid		26
! #define Anum_pg_class_relacl			27
  
  /* ----------------
   *		initial contents of pg_class
***************
*** 139,151 ****
   * ----------------
   */
  
! DATA(insert OID = 1247 (  pg_type		PGNSP 71 PGUID 0 1247 0 0 0 0 0 f f r 23 0 0 0 0 0 t f f f _null_ ));
  DESCR("");
! DATA(insert OID = 1249 (  pg_attribute	PGNSP 75 PGUID 0 1249 0 0 0 0 0 f f r 17 0 0 0 0 0 f f f f _null_ ));
  DESCR("");
! DATA(insert OID = 1255 (  pg_proc		PGNSP 81 PGUID 0 1255 0 0 0 0 0 f f r 18 0 0 0 0 0 t f f f _null_ ));
  DESCR("");
! DATA(insert OID = 1259 (  pg_class		PGNSP 83 PGUID 0 1259 0 0 0 0 0 f f r 25 0 0 0 0 0 t f f f _null_ ));
  DESCR("");
  
  #define		  RELKIND_INDEX			  'i'		/* secondary index */
--- 143,156 ----
   * ----------------
   */
  
! /* Note: the "3" here stands for FirstNormalTransactionId */
! DATA(insert OID = 1247 (  pg_type		PGNSP 71 PGUID 0 1247 0 0 0 0 0 f f r 23 0 0 0 0 0 t f f f 3 3 _null_ ));
  DESCR("");
! DATA(insert OID = 1249 (  pg_attribute	PGNSP 75 PGUID 0 1249 0 0 0 0 0 f f r 17 0 0 0 0 0 f f f f 3 3 _null_ ));
  DESCR("");
! DATA(insert OID = 1255 (  pg_proc		PGNSP 81 PGUID 0 1255 0 0 0 0 0 f f r 18 0 0 0 0 0 t f f f 3 3 _null_ ));
  DESCR("");
! DATA(insert OID = 1259 (  pg_class		PGNSP 83 PGUID 0 1259 0 0 0 0 0 f f r 27 0 0 0 0 0 t f f f 3 3 _null_ ));
  DESCR("");
  
  #define		  RELKIND_INDEX			  'i'		/* secondary index */
Index: src/include/catalog/pg_database.h
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/include/catalog/pg_database.h,v
retrieving revision 1.40
diff -c -r1.40 pg_database.h
*** src/include/catalog/pg_database.h	5 Mar 2006 15:58:54 -0000	1.40
--- src/include/catalog/pg_database.h	28 Jun 2006 21:33:43 -0000
***************
*** 43,49 ****
  	int4		datconnlimit;	/* max connections allowed (-1=no limit) */
  	Oid			datlastsysoid;	/* highest OID to consider a system OID */
  	TransactionId datvacuumxid; /* all XIDs before this are vacuumed */
! 	TransactionId datfrozenxid; /* all XIDs before this are frozen */
  	Oid			dattablespace;	/* default table space for this DB */
  	text		datconfig[1];	/* database-specific GUC (VAR LENGTH) */
  	aclitem		datacl[1];		/* access permissions (VAR LENGTH) */
--- 43,49 ----
  	int4		datconnlimit;	/* max connections allowed (-1=no limit) */
  	Oid			datlastsysoid;	/* highest OID to consider a system OID */
  	TransactionId datvacuumxid; /* all XIDs before this are vacuumed */
! 	TransactionId datminxid;	/* minimum XID present anywhere in the DB */
  	Oid			dattablespace;	/* default table space for this DB */
  	text		datconfig[1];	/* database-specific GUC (VAR LENGTH) */
  	aclitem		datacl[1];		/* access permissions (VAR LENGTH) */
***************
*** 69,75 ****
  #define Anum_pg_database_datconnlimit	6
  #define Anum_pg_database_datlastsysoid	7
  #define Anum_pg_database_datvacuumxid	8
! #define Anum_pg_database_datfrozenxid	9
  #define Anum_pg_database_dattablespace	10
  #define Anum_pg_database_datconfig		11
  #define Anum_pg_database_datacl			12
--- 69,75 ----
  #define Anum_pg_database_datconnlimit	6
  #define Anum_pg_database_datlastsysoid	7
  #define Anum_pg_database_datvacuumxid	8
! #define Anum_pg_database_datminxid		9
  #define Anum_pg_database_dattablespace	10
  #define Anum_pg_database_datconfig		11
  #define Anum_pg_database_datacl			12
Index: src/include/commands/vacuum.h
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/include/commands/vacuum.h,v
retrieving revision 1.63
diff -c -r1.63 vacuum.h
*** src/include/commands/vacuum.h	5 Mar 2006 15:58:55 -0000	1.63
--- src/include/commands/vacuum.h	28 Jun 2006 21:28:14 -0000
***************
*** 114,128 ****
  extern void vac_open_indexes(Relation relation, LOCKMODE lockmode,
  				 int *nindexes, Relation **Irel);
  extern void vac_close_indexes(int nindexes, Relation *Irel, LOCKMODE lockmode);
! extern void vac_update_relstats(Oid relid,
! 					BlockNumber num_pages,
! 					double num_tuples,
! 					bool hasindex);
  extern void vacuum_set_xid_limits(VacuumStmt *vacstmt, bool sharedRel,
  					  TransactionId *oldestXmin,
  					  TransactionId *freezeLimit);
  extern bool vac_is_partial_index(Relation indrel);
  extern void vacuum_delay_point(void);
  
  /* in commands/vacuumlazy.c */
  extern void lazy_vacuum_rel(Relation onerel, VacuumStmt *vacstmt);
--- 114,128 ----
  extern void vac_open_indexes(Relation relation, LOCKMODE lockmode,
  				 int *nindexes, Relation **Irel);
  extern void vac_close_indexes(int nindexes, Relation *Irel, LOCKMODE lockmode);
! extern void vac_update_relstats(Oid relid, BlockNumber num_pages,
! 					double num_tuples, bool hasindex,
! 					TransactionId minxid, TransactionId vacuumxid);
  extern void vacuum_set_xid_limits(VacuumStmt *vacstmt, bool sharedRel,
  					  TransactionId *oldestXmin,
  					  TransactionId *freezeLimit);
  extern bool vac_is_partial_index(Relation indrel);
  extern void vacuum_delay_point(void);
+ extern TransactionId vactuple_get_minxid(HeapTuple tuple);
  
  /* in commands/vacuumlazy.c */
  extern void lazy_vacuum_rel(Relation onerel, VacuumStmt *vacstmt);
Index: src/include/libpq/hba.h
===================================================================
RCS file: /home/alvherre/cvs/pgsql/src/include/libpq/hba.h,v
retrieving revision 1.42
diff -c -r1.42 hba.h
*** src/include/libpq/hba.h	6 Mar 2006 17:41:44 -0000	1.42
--- src/include/libpq/hba.h	28 Jun 2006 18:02:59 -0000
***************
*** 40,46 ****
  extern int	hba_getauthmethod(hbaPort *port);
  extern int	authident(hbaPort *port);
  extern bool read_pg_database_line(FILE *fp, char *dbname, Oid *dboid,
! 					  Oid *dbtablespace, TransactionId *dbfrozenxid,
  					  TransactionId *dbvacuumxid);
  
  #endif   /* HBA_H */
--- 40,46 ----
  extern int	hba_getauthmethod(hbaPort *port);
  extern int	authident(hbaPort *port);
  extern bool read_pg_database_line(FILE *fp, char *dbname, Oid *dboid,
! 					  Oid *dbtablespace, TransactionId *dbminxid,
  					  TransactionId *dbvacuumxid);
  
  #endif   /* HBA_H */