Try to detect oversize tuple before corrupting relation, instead of

after...

diff --git a/src/backend/access/heap/hio.c b/src/backend/access/heap/hio.c
index 595c79e0236f50ee380f1fd7e92129068b764a15..d21d219c10c9eea4941ba07ee703544d58eeba1e 100644 (file)
--- a/src/backend/access/heap/hio.c
+++ b/src/backend/access/heap/hio.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *       $Id: hio.c,v 1.26 1999/07/19 07:07:18 momjian Exp $
+ *       $Id: hio.c,v 1.27 1999/11/29 04:34:55 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -107,10 +107,20 @@ RelationPutHeapTupleAtEnd(Relation relation, HeapTuple tuple)
        ItemId          itemId;
        Item            item;
 
+       len = (unsigned) MAXALIGN(tuple->t_len); /* be conservative */
+
+       /*
+        * If we're gonna fail for oversize tuple, do it right away...
+        * this code should go away eventually.
+        */
+       if (len > MaxTupleSize)
+               elog(ERROR, "Tuple is too big: size %d, max size %d",
+                        len, MaxTupleSize);
+
        /*
-        * Lock relation for extention. We can use LockPage here as long as in
+        * Lock relation for extension. We can use LockPage here as long as in
         * all other places we use page-level locking for indices only.
-        * Alternatevely, we could define pseudo-table as we do for
+        * Alternatively, we could define pseudo-table as we do for
         * transactions with XactLockTable.
         */
        if (!relation->rd_myxactonly)
@@ -122,17 +132,17 @@ RelationPutHeapTupleAtEnd(Relation relation, HeapTuple tuple)
         * relation.  A good optimization would be to get this to actually
         * work properly.
         */
-
        lastblock = RelationGetNumberOfBlocks(relation);
 
+       /*
+        * Get the last existing page --- may need to create the first one
+        * if this is a virgin relation.
+        */
        if (lastblock == 0)
        {
+               /* what exactly is this all about??? */
                buffer = ReadBuffer(relation, lastblock);
                pageHeader = (Page) BufferGetPage(buffer);
-
-               /*
-                * There was IF instead of ASSERT here ?!
-                */
                Assert(PageIsNew((PageHeader) pageHeader));
                buffer = ReleaseAndReadBuffer(buffer, relation, P_NEW);
                pageHeader = (Page) BufferGetPage(buffer);
@@ -143,13 +153,10 @@ RelationPutHeapTupleAtEnd(Relation relation, HeapTuple tuple)
 
        LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
        pageHeader = (Page) BufferGetPage(buffer);
-       len = (unsigned) MAXALIGN(tuple->t_len); /* be conservative */
 
        /*
-        * Note that this is true if the above returned a bogus page, which it
-        * will do for a completely empty relation.
+        * Is there room on the last existing page?
         */
-
        if (len > PageGetFreeSpace(pageHeader))
        {
                LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
@@ -159,12 +166,18 @@ RelationPutHeapTupleAtEnd(Relation relation, HeapTuple tuple)
                PageInit(pageHeader, BufferGetPageSize(buffer), 0);
 
                if (len > PageGetFreeSpace(pageHeader))
+               {
+                       /*
+                        * BUG: by elog'ing here, we leave the new buffer locked and not
+                        * marked dirty, which may result in an invalid page header
+                        * being left on disk.  But we should not get here given the
+                        * test at the top of the routine, and the whole deal should
+                        * go away when we implement tuple splitting anyway...
+                        */
                        elog(ERROR, "Tuple is too big: size %d", len);
+               }
        }
 
-       if (len > MaxTupleSize)
-               elog(ERROR, "Tuple is too big: size %d, max size %d", len, MaxTupleSize);
-
        if (!relation->rd_myxactonly)
                UnlockPage(relation, 0, ExclusiveLock);
 
@@ -178,7 +191,7 @@ RelationPutHeapTupleAtEnd(Relation relation, HeapTuple tuple)
 
        ItemPointerSet(&((HeapTupleHeader) item)->t_ctid, lastblock, offnum);
 
-       /* return an accurate tuple */
+       /* return an accurate tuple self-pointer */
        ItemPointerSet(&tuple->t_self, lastblock, offnum);
 
        LockBuffer(buffer, BUFFER_LOCK_UNLOCK);