Transaction IDs wrap around, per my proposal of 13-Aug-01. More

documentation to come, but the code is all here.  initdb forced.

Author: tglsfdc

doc/src/sgml/catalogs.sgml

@@ -1,6 +1,6 @@
 <!--
  Documentation of the system catalogs, directed toward PostgreSQL developers
- $Header: /cvsroot/pgsql/doc/src/sgml/catalogs.sgml,v 2.21 2001/08/21 16:35:58 tgl Exp $
+ $Header: /cvsroot/pgsql/doc/src/sgml/catalogs.sgml,v 2.22 2001/08/26 16:55:58 tgl Exp $
  -->
 
 <chapter id="catalogs">
@@ -840,11 +840,34 @@
       <entry><type>oid</type></entry>
       <entry></entry>
       <entry>
-       Last oid in existence after the database was created; useful
+       Last system OID in the database; useful
        particularly to <application>pg_dump</application>
       </entry>
      </row>
 
+     <row>
+      <entry>datvacuumxid</entry>
+      <entry><type>xid</type></entry>
+      <entry></entry>
+      <entry>
+       All tuples 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>datfrozenxid</entry>
+      <entry><type>xid</type></entry>
+      <entry></entry>
+      <entry>
+       All tuples 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 wraparound problems.
+      </entry>
+     </row>
+
      <row>
       <entry>datpath</entry>
       <entry><type>text</type></entry>

doc/src/sgml/ref/create_database.sgml

@@ -1,5 +1,5 @@
 <!--
-$Header: /cvsroot/pgsql/doc/src/sgml/ref/create_database.sgml,v 1.17 2000/11/15 19:43:39 petere Exp $
+$Header: /cvsroot/pgsql/doc/src/sgml/ref/create_database.sgml,v 1.18 2001/08/26 16:55:59 tgl Exp $
 Postgres documentation
 -->
 
@@ -284,6 +284,20 @@ comment from Olly; response from Thomas...
    simply by setting the flag false).  The <literal>template0</literal>
    database is normally marked this way to prevent modification of it.
   </para>
+
+  <para>
+   After preparing a template database, or making any changes to one,
+   it is a good idea to perform
+   <command>VACUUM FREEZE</> or <command>VACUUM FULL FREEZE</> in that
+   database.  If this is done when there are no other open transactions
+   in the same database, then it is guaranteed that all tuples in the
+   database are <quote>frozen</> and will not be subject to transaction
+   ID wraparound problems.  This is particularly important for a database
+   that will have <literal>datallowconn</literal> set to false, since it
+   will be impossible to do routine maintenance <command>VACUUM</>s on
+   such a database.
+    See the Administrator's Guide for more information.
+  </para>
   </refsect2>
  </refsect1>
 

doc/src/sgml/ref/vacuum.sgml

@@ -1,5 +1,5 @@
 <!--
-$Header: /cvsroot/pgsql/doc/src/sgml/ref/vacuum.sgml,v 1.17 2001/07/10 22:09:28 tgl Exp $
+$Header: /cvsroot/pgsql/doc/src/sgml/ref/vacuum.sgml,v 1.18 2001/08/26 16:55:59 tgl Exp $
 Postgres documentation
 -->
 
@@ -20,11 +20,11 @@ Postgres documentation
  </refnamediv>
  <refsynopsisdiv>
   <refsynopsisdivinfo>
-   <date>2001-07-10</date>
+   <date>2001-08-26</date>
   </refsynopsisdivinfo>
   <synopsis>
-VACUUM [ FULL ] [ VERBOSE ] [ <replaceable class="PARAMETER">table</replaceable> ]
-VACUUM [ FULL ] [ VERBOSE ] ANALYZE [ <replaceable class="PARAMETER">table</replaceable> [ (<replaceable class="PARAMETER">column</replaceable> [, ...] ) ] ]
+VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] [ <replaceable class="PARAMETER">table</replaceable> ]
+VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] ANALYZE [ <replaceable class="PARAMETER">table</replaceable> [ (<replaceable class="PARAMETER">column</replaceable> [, ...] ) ] ]
   </synopsis>
 
   <refsect2 id="R2-SQL-VACUUM-1">
@@ -46,6 +46,14 @@ VACUUM [ FULL ] [ VERBOSE ] ANALYZE [ <replaceable class="PARAMETER">table</repl
        </para>
       </listitem>
      </varlistentry>
+     <varlistentry>
+      <term>FREEZE</term>
+      <listitem>
+       <para>
+        Selects aggressive <quote>freezing</quote> of tuples.
+       </para>
+      </listitem>
+     </varlistentry>
      <varlistentry>
       <term>VERBOSE</term>
       <listitem>
@@ -169,21 +177,38 @@ NOTICE:  Index <replaceable class="PARAMETER">index</replaceable>: Pages 28;
   </para>
 
   <para>
-   Plain <command>VACUUM</command> simply reclaims space and makes it
+   <command>VACUUM ANALYZE</command> performs a <command>VACUUM</command>
+   and then an <command>ANALYZE</command> for each selected table.  This
+   is a handy combination form for routine maintenance scripts.  See
+   <xref linkend="sql-analyze" endterm="sql-analyze-title">
+   for more details about its processing.
+  </para>
+
+  <para>
+   Plain <command>VACUUM</command> (without <literal>FULL</>) simply reclaims
+   space and makes it
    available for re-use.  This form of the command can operate in parallel
    with normal reading and writing of the table.  <command>VACUUM
    FULL</command> does more extensive processing, including moving of tuples
    across blocks to try to compact the table to the minimum number of disk
-   blocks.  This is much slower and requires an exclusive lock on each table
-   while it is being processed.
+   blocks.  This form is much slower and requires an exclusive lock on each
+   table while it is being processed.
   </para>
 
   <para>
-   <command>VACUUM ANALYZE</command> performs a <command>VACUUM</command>
-   and then an <command>ANALYZE</command> for each selected table.  This
-   is a handy combination form for routine maintenance scripts.  See
-   <xref linkend="sql-analyze" endterm="sql-analyze-title">
-   for more details about its processing.
+   <command>FREEZE</command> is a special-purpose option that
+   causes tuples to be marked <quote>frozen</quote> as soon as possible,
+   rather than waiting until they are quite old.  If this is done when there
+   are no other open transactions in the same database, then it is guaranteed
+   that all tuples in the database are <quote>frozen</> and will not be
+   subject to transaction ID wraparound problems, no matter how long the
+   database is left un-vacuumed.
+   <command>FREEZE</command> is not recommended for routine use.  Its only
+   intended usage is in connection with preparation of user-defined template
+   databases, or other databases that are completely read-only and will not
+   receive routine maintenance <command>VACUUM</> operations.
+   See <xref linkend="sql-createdatabase" endterm="sql-createdatabase-title">
+   for details.
   </para>
 
   <refsect2 id="R2-SQL-VACUUM-3">

src/backend/access/transam/clog.c

@@ -13,7 +13,7 @@
  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Header: /cvsroot/pgsql/src/backend/access/transam/clog.c,v 1.2 2001/08/25 23:24:39 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/clog.c,v 1.3 2001/08/26 16:55:59 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -762,8 +762,12 @@ ExtendCLOG(TransactionId newestXact)
 {
 	int			pageno;
 
-	/* No work except at first XID of a page */
-	if (TransactionIdToPgIndex(newestXact) != 0)
+	/*
+	 * No work except at first XID of a page.  But beware: just after
+	 * wraparound, the first XID of page zero is FirstNormalTransactionId.
+	 */
+	if (TransactionIdToPgIndex(newestXact) != 0 &&
+		!TransactionIdEquals(newestXact, FirstNormalTransactionId))
 		return;
 
 	pageno = TransactionIdToPage(newestXact);
@@ -818,6 +822,18 @@ TruncateCLOG(TransactionId oldestXact)
 	S_LOCK(&(ClogCtl->control_lck));
 
 restart:;
+	/*
+	 * While we are holding the lock, make an important safety check:
+	 * the planned cutoff point must be <= the current CLOG endpoint page.
+	 * Otherwise we have already wrapped around, and proceeding with the
+	 * truncation would risk removing the current CLOG segment.
+	 */
+	if (CLOGPagePrecedes(ClogCtl->latest_page_number, cutoffPage))
+	{
+		S_UNLOCK(&(ClogCtl->control_lck));
+		elog(LOG, "unable to truncate commit log: apparent wraparound");
+		return;
+	}
 
 	for (slotno = 0; slotno < NUM_CLOG_BUFFERS; slotno++)
 	{

src/backend/access/transam/transam.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.47 2001/08/25 18:52:41 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.48 2001/08/26 16:55:59 tgl Exp $
  *
  * NOTES
  *	  This file contains the high level access-method interface to the
@@ -236,3 +236,68 @@ TransactionIdAbort(TransactionId transactionId)
 
 	TransactionLogUpdate(transactionId, TRANSACTION_STATUS_ABORTED);
 }
+
+
+/*
+ * TransactionIdPrecedes --- is id1 logically < id2?
+ */
+bool
+TransactionIdPrecedes(TransactionId id1, TransactionId id2)
+{
+	/*
+	 * If either ID is a permanent XID then we can just do unsigned
+	 * comparison.  If both are normal, do a modulo-2^31 comparison.
+	 */
+	int32		diff;
+
+	if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
+		return (id1 < id2);
+
+	diff = (int32) (id1 - id2);
+	return (diff < 0);
+}
+
+/*
+ * TransactionIdPrecedesOrEquals --- is id1 logically <= id2?
+ */
+bool
+TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2)
+{
+	int32		diff;
+
+	if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
+		return (id1 <= id2);
+
+	diff = (int32) (id1 - id2);
+	return (diff <= 0);
+}
+
+/*
+ * TransactionIdFollows --- is id1 logically > id2?
+ */
+bool
+TransactionIdFollows(TransactionId id1, TransactionId id2)
+{
+	int32		diff;
+
+	if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
+		return (id1 > id2);
+
+	diff = (int32) (id1 - id2);
+	return (diff > 0);
+}
+
+/*
+ * TransactionIdFollowsOrEquals --- is id1 logically >= id2?
+ */
+bool
+TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2)
+{
+	int32		diff;
+
+	if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
+		return (id1 >= id2);
+
+	diff = (int32) (id1 - id2);
+	return (diff >= 0);
+}

src/backend/access/transam/xid.c

@@ -6,55 +6,44 @@
  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- *	$Id: xid.c,v 1.32 2001/08/23 23:06:37 tgl Exp $
- *
- * OLD COMMENTS
- * XXX WARNING
- *		Much of this file will change when we change our representation
- *		of transaction ids -cim 3/23/90
- *
- * It is time to make the switch from 5 byte to 4 byte transaction ids
- * This file was totally reworked. -mer 5/22/92
+ *	$Id: xid.c,v 1.33 2001/08/26 16:55:59 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
 
 #include "postgres.h"
 
+#include <limits.h>
+
 #include "access/xact.h"
 
+
 #define PG_GETARG_TRANSACTIONID(n)	DatumGetTransactionId(PG_GETARG_DATUM(n))
 #define PG_RETURN_TRANSACTIONID(x)	return TransactionIdGetDatum(x)
 
 
 Datum
 xidin(PG_FUNCTION_ARGS)
 {
-	char	   *representation = PG_GETARG_CSTRING(0);
+	char	   *str = PG_GETARG_CSTRING(0);
 
-	PG_RETURN_TRANSACTIONID((TransactionId) atol(representation));
+	PG_RETURN_TRANSACTIONID((TransactionId) strtoul(str, NULL, 0));
 }
 
 Datum
 xidout(PG_FUNCTION_ARGS)
 {
 	TransactionId transactionId = PG_GETARG_TRANSACTIONID(0);
 	/* maximum 32 bit unsigned integer representation takes 10 chars */
-	char	   *representation = palloc(11);
+	char	   *str = palloc(11);
 
-	snprintf(representation, 11, "%lu", (unsigned long) transactionId);
+	snprintf(str, 11, "%lu", (unsigned long) transactionId);
 
-	PG_RETURN_CSTRING(representation);
+	PG_RETURN_CSTRING(str);
 }
 
-/* ----------------------------------------------------------------
- *		xideq
- * ----------------------------------------------------------------
- */
-
 /*
- *		xideq			- returns 1, iff xid1 == xid2
- *								  0  else;
+ *		xideq			- are two xids equal?
  */
 Datum
 xideq(PG_FUNCTION_ARGS)
@@ -64,3 +53,19 @@ xideq(PG_FUNCTION_ARGS)
 
 	PG_RETURN_BOOL(TransactionIdEquals(xid1, xid2));
 }
+
+/*
+ *		xid_age			- compute age of an XID (relative to current xact)
+ */
+Datum
+xid_age(PG_FUNCTION_ARGS)
+{
+	TransactionId xid = PG_GETARG_TRANSACTIONID(0);
+	TransactionId now = GetCurrentTransactionId();
+
+	/* Permanent XIDs are always infinitely old */
+	if (! TransactionIdIsNormal(xid))
+		PG_RETURN_INT32(INT_MAX);
+
+	PG_RETURN_INT32((int32) (now - xid));
+}