Tighten coding of inner loops in nocachegetattr ...

seems to have improved speed of routine by 5% or so ...

diff --git a/src/backend/access/common/heaptuple.c b/src/backend/access/common/heaptuple.c
index 3d0b684306df0098e815dbaad60f9eb8e681a309..4cf0098f5ee16862181cfed3dbe63a593040eacb 100644 (file)
--- a/src/backend/access/common/heaptuple.c
+++ b/src/backend/access/common/heaptuple.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.46 1998/11/27 19:51:27 vadim Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.47 1999/01/24 22:53:25 tgl Exp $
  *
  * NOTES
  *   The old interface functions have been converted to macros
@@ -311,13 +311,13 @@ heap_getsysattr(HeapTuple tup, Buffer b, int attnum)
  *
  *     This caches attribute offsets in the attribute descriptor.
  *
- *     an alternate way to speed things up would be to cache offsets
+ *     An alternate way to speed things up would be to cache offsets
  *     with the tuple, but that seems more difficult unless you take
  *     the storage hit of actually putting those offsets into the
  *     tuple you send to disk.  Yuck.
  *
  *     This scheme will be slightly slower than that, but should
- *     preform well for queries which hit large #'s of tuples.  After
+ *     perform well for queries which hit large #'s of tuples.  After
  *     you cache the offsets once, examining all the other tuples using
  *     the same attribute descriptor will go much quicker. -cim 5/4/91
  * ----------------
@@ -331,8 +331,8 @@ nocachegetattr(HeapTuple tuple,
    char               *tp;                     /* ptr to att in tuple */
    HeapTupleHeader     tup = tuple->t_data;
    bits8              *bp = tup->t_bits;       /* ptr to att in tuple */
-   int                 slow;                   /* do we have to walk nulls? */
    Form_pg_attribute  *att = tupleDesc->attrs;
+   int                 slow = 0;               /* do we have to walk nulls? */
 
 
 #if IN_MACRO
@@ -343,6 +343,8 @@ nocachegetattr(HeapTuple tuple,
        *isnull = false;
 #endif
 
+   attnum--;
+
    /* ----------------
     *   Three cases:
     *
@@ -354,8 +356,6 @@ nocachegetattr(HeapTuple tuple,
 
    if (HeapTupleNoNulls(tuple))
    {
-       attnum--;
-
 #if IN_MACRO
 /* This is handled in the macro */
        if (att[attnum]->attcacheoff != -1)
@@ -373,20 +373,13 @@ nocachegetattr(HeapTuple tuple,
            return (Datum) fetchatt(&(att[0]), (char *) tup + tup->t_hoff);
        }
 #endif
-
-       slow = 0;
    }
    else
    {
-
        /*
         * there's a null somewhere in the tuple
         */
 
-       tp = (char *) tup + tup->t_hoff;
-       slow = 0;
-       attnum--;
-
        /* ----------------
         *      check to see if desired att is null
         * ----------------
@@ -403,34 +396,27 @@ nocachegetattr(HeapTuple tuple,
 #endif
 
        /* ----------------
-        *      Now check to see if any preceeding bits are null...
+        *      Now check to see if any preceding bits are null...
         * ----------------
         */
        {
-           int         i = 0;  /* current offset in bp */
-           int         mask;   /* bit in byte we're looking at */
-           char        n;      /* current byte in bp */
-           int         byte,
-                       finalbit;
-
-           byte = attnum >> 3;
-           finalbit = attnum & 0x07;
+           int         byte = attnum >> 3;
+           int         finalbit = attnum & 0x07;
 
-           for (; i <= byte && !slow; i++)
+           /* check for nulls "before" final bit of last byte */
+           if ((~ bp[byte]) & ((1 << finalbit) - 1))
+               slow = 1;
+           else
            {
-               n = bp[i];
-               if (i < byte)
+               /* check for nulls in any "earlier" bytes */
+               int     i;
+               for (i = 0; i < byte; i++)
                {
-                   /* check for nulls in any "earlier" bytes */
-                   if ((~n) != 0)
-                       slow = 1;
-               }
-               else
-               {
-                   /* check for nulls "before" final bit of last byte */
-                   mask = (1 << finalbit) - 1;
-                   if ((~n) & mask)
+                   if (bp[i] != 0xFF)
+                   {
                        slow = 1;
+                       break;
+                   }
                }
            }
        }
@@ -449,24 +435,29 @@ nocachegetattr(HeapTuple tuple,
                                    tp + att[attnum]->attcacheoff);
        }
        else if (attnum == 0)
-           return (Datum) fetchatt(&(att[0]), (char *) tp);
+           return (Datum) fetchatt(&(att[0]), tp);
        else if (!HeapTupleAllFixed(tuple))
        {
-           int         j = 0;
-
+           int         j;
            /*
             * In for(), we make this <= and not < because we want to test
             * if we can go past it in initializing offsets.
             */
-           for (j = 0; j <= attnum && !slow; j++)
+           for (j = 0; j <= attnum; j++)
+           {
                if (att[j]->attlen < 1 && !VARLENA_FIXED_SIZE(att[j]))
+               {
                    slow = 1;
+                   break;
+               }
+           }
        }
    }
 
    /*
-    * if slow is zero, and we got here, we know that we have a tuple with
-    * no nulls.  We also have to initialize the remainder of the
+    * If slow is zero, and we got here, we know that we have a tuple with
+    * no nulls or varlenas before the target attribute.
+    * If possible, we also want to initialize the remainder of the
     * attribute cached offset values.
     */
    if (!slow)
@@ -550,7 +541,8 @@ nocachegetattr(HeapTuple tuple,
 
            off = att_addlength(off, att[i]->attlen, tp + off);
 
-           if (att[i]->attlen == -1 && !VARLENA_FIXED_SIZE(att[i]))
+           if (usecache &&
+               att[i]->attlen == -1 && !VARLENA_FIXED_SIZE(att[i]))
                usecache = false;
        }