Reduce heap tuple header size

This patch, which is built upon the "HeapTupleHeader accessor macros"
patch from 2002-06-10, is supposed to reduce the heap tuple header size
by four bytes on most architectures.  Of course it changes the on-disk
tuple format and therefore requires initdb.  As I have (once more)
opened my mouth too wide, I'll have to provide a heap file conversion
utility, if this patch gets accepted...  More on this later.

======================
 All 81 tests passed.
======================

It's late now, I'll do more tests tomorrow.

Good night
 Manfred

diff -ru ../orig/src/backend/access/heap/heapam.c src/backend/access/heap/heapam.c
--- ../orig/src/backend/access/heap/heapam.c    2002-06-13 19:34:48.000000000 +0200
+++ src/backend/access/heap/heapam.c    2002-06-13 22:31:42.000000000 +0200
@@ -2204,7 +2204,7 @@
         htup->t_infomask = HEAP_XMAX_INVALID | xlhdr.mask;
         HeapTupleHeaderSetXmin(htup, record->xl_xid);
         HeapTupleHeaderSetCmin(htup, FirstCommandId);
-        HeapTupleHeaderSetXmax(htup, InvalidTransactionId);
+        HeapTupleHeaderSetXmaxInvalid(htup);
         HeapTupleHeaderSetCmax(htup, FirstCommandId);

         offnum = PageAddItem(page, (Item) htup, newlen, offnum,
diff -ru ../orig/src/include/access/htup.h src/include/access/htup.h
--- ../orig/src/include/access/htup.h    2002-06-13 19:34:49.000000000 +0200
+++ src/include/access/htup.h    2002-06-14 01:12:47.000000000 +0200
@@ -57,15 +57,24 @@
  * Also note that we omit the nulls bitmap if t_infomask shows that there
  * are no nulls in the tuple.
  */
+/*
+** We store five "virtual" fields Xmin, Cmin, Xmax, Cmax, and Xvac
+** in three physical fields t_xmin, t_cid, t_xmax:
+** CommandId     Cmin;        insert CID stamp
+** CommandId     Cmax;        delete CommandId stamp
+** TransactionId Xmin;        insert XID stamp
+** TransactionId Xmax;        delete XID stamp
+** TransactionId Xvac;        used by VACCUUM
+**
+** This assumes, that a CommandId can be stored in a TransactionId.
+*/
 typedef struct HeapTupleHeaderData
 {
     Oid            t_oid;            /* OID of this tuple -- 4 bytes */

-    CommandId    t_cmin;            /* insert CID stamp -- 4 bytes each */
-    CommandId    t_cmax;            /* delete CommandId stamp */
-
-    TransactionId t_xmin;        /* insert XID stamp -- 4 bytes each */
-    TransactionId t_xmax;        /* delete XID stamp */
+    TransactionId t_xmin;        /* Xmin -- 4 bytes each */
+    TransactionId t_cid;        /* Cmin, Cmax, Xvac */
+    TransactionId t_xmax;        /* Xmax, Cmax */

     ItemPointerData t_ctid;        /* current TID of this or newer tuple */

@@ -75,7 +84,7 @@

     uint8        t_hoff;            /* sizeof header incl. bitmap, padding */

-    /* ^ - 31 bytes - ^ */
+    /* ^ - 27 bytes - ^ */

     bits8        t_bits[1];        /* bitmap of NULLs -- VARIABLE LENGTH */

@@ -96,6 +105,8 @@
                                          * attribute(s) */
 #define HEAP_HASEXTENDED        0x000C    /* the two above combined */

+#define HEAP_XMIN_IS_XMAX        0x0040    /* created and deleted in the */
+                                        /* same transaction
*/
 #define HEAP_XMAX_UNLOGGED        0x0080    /* to lock tuple for update */
                                         /* without logging
*/
 #define HEAP_XMIN_COMMITTED        0x0100    /* t_xmin committed */
@@ -108,6 +119,7 @@
                                          * vacuum */
 #define HEAP_MOVED_IN            0x8000    /* moved from another place by
                                          * vacuum */
+#define HEAP_MOVED (HEAP_MOVED_OFF | HEAP_MOVED_IN)

 #define HEAP_XACT_MASK            0xFFF0    /* visibility-related bits */

@@ -116,53 +128,100 @@
 /* HeapTupleHeader accessor macros */

 #define HeapTupleHeaderGetXmin(tup) \
-    ((tup)->t_xmin)
+( \
+    (tup)->t_xmin \
+)

 #define HeapTupleHeaderGetXmax(tup) \
-    ((tup)->t_xmax)
+( \
+    ((tup)->t_infomask & HEAP_XMIN_IS_XMAX) ? \
+        (tup)->t_xmin \
+    : \
+        (tup)->t_xmax \
+)

-/* no AssertMacro, because this is read as a system-defined attribute also */
+/* no AssertMacro, because this is read as a system-defined attribute */
 #define HeapTupleHeaderGetCmin(tup) \
 ( \
-    (tup)->t_cmin \
+    ((tup)->t_infomask & HEAP_MOVED) ? \
+        FirstCommandId \
+    : \
+    ( \
+        ((tup)->t_infomask & (HEAP_XMIN_IS_XMAX | HEAP_XMAX_INVALID)) ? \
+            (CommandId) (tup)->t_cid \
+        : \
+            FirstCommandId \
+    ) \
 )

 #define HeapTupleHeaderGetCmax(tup) \
-    ((tup)->t_cmax)
+( \
+    ((tup)->t_infomask & HEAP_MOVED) ? \
+        FirstCommandId \
+    : \
+    ( \
+        ((tup)->t_infomask & (HEAP_XMIN_IS_XMAX | HEAP_XMAX_INVALID)) ? \
+            (CommandId) (tup)->t_xmax \
+        : \
+            (CommandId) (tup)->t_cid \
+    ) \
+)

 #define HeapTupleHeaderGetXvac(tup) \
 ( \
-    AssertMacro((tup)->t_infomask & (HEAP_MOVED_IN | HEAP_MOVED_OFF)), \
-    (TransactionId) (tup)->t_cmin \
+    AssertMacro((tup)->t_infomask & HEAP_MOVED), \
+    (tup)->t_cid \
 )


 #define HeapTupleHeaderSetXmin(tup, xid) \
-    (TransactionIdStore((xid), &(tup)->t_xmin))
+( \
+    TransactionIdStore((xid), &(tup)->t_xmin) \
+)

 #define HeapTupleHeaderSetXminInvalid(tup) \
-    (StoreInvalidTransactionId(&(tup)->t_xmin))
+do { \
+    (tup)->t_infomask &= ~HEAP_XMIN_IS_XMAX; \
+    StoreInvalidTransactionId(&(tup)->t_xmin); \
+} while (0)

 #define HeapTupleHeaderSetXmax(tup, xid) \
-    (TransactionIdStore((xid), &(tup)->t_xmax))
+do { \
+    if (TransactionIdEquals((tup)->t_xmin, (xid))) \
+        (tup)->t_infomask |= HEAP_XMIN_IS_XMAX; \
+    else \
+    { \
+        (tup)->t_infomask &= ~HEAP_XMIN_IS_XMAX; \
+        TransactionIdStore((xid), &(tup)->t_xmax); \
+    } \
+} while (0)

 #define HeapTupleHeaderSetXmaxInvalid(tup) \
-    (StoreInvalidTransactionId(&(tup)->t_xmax))
+do { \
+    (tup)->t_infomask &= ~HEAP_XMIN_IS_XMAX; \
+    StoreInvalidTransactionId(&(tup)->t_xmax); \
+} while (0)

 #define HeapTupleHeaderSetCmin(tup, cid) \
-( \
-    AssertMacro(!((tup)->t_infomask & (HEAP_MOVED_IN | HEAP_MOVED_OFF))), \
-    (tup)->t_cmin = (cid) \
-)
+do { \
+    Assert(!((tup)->t_infomask & HEAP_MOVED)); \
+    TransactionIdStore((TransactionId) (cid), &(tup)->t_cid); \
+} while (0)

 #define HeapTupleHeaderSetCmax(tup, cid) \
-    ((tup)->t_cmax = (cid))
+do { \
+    Assert(!((tup)->t_infomask & HEAP_MOVED)); \
+    if ((tup)->t_infomask & HEAP_XMIN_IS_XMAX) \
+        TransactionIdStore((TransactionId) (cid), &(tup)->t_xmax); \
+    else \
+        TransactionIdStore((TransactionId) (cid), &(tup)->t_cid); \
+} while (0)

 #define HeapTupleHeaderSetXvac(tup, xid) \
-( \
-    AssertMacro((tup)->t_infomask & (HEAP_MOVED_IN | HEAP_MOVED_OFF)), \
-    TransactionIdStore((xid), (TransactionId *) &((tup)->t_cmin)) \
-)
+do { \
+    Assert((tup)->t_infomask & HEAP_MOVED); \
+    TransactionIdStore((xid), &(tup)->t_cid); \
+} while (0)


 /*