Merge pnousiainen@bk-internal.mysql.com:/home/bk/mysql-4.1-ndb

into mysql.com:/space/pekka/ndb/version/my41

12 files changed, 189 insertions, 123 deletions

diff --git a/ndb/include/kernel/signaldata/TuxMaint.hpp b/ndb/include/kernel/signaldata/TuxMaint.hpp
index 44deb33be80..9fee031dc41 100644
--- a/ndb/include/kernel/signaldata/TuxMaint.hpp
+++ b/ndb/include/kernel/signaldata/TuxMaint.hpp
@@ -39,7 +39,7 @@ public:
     SearchError = 895,  // add + found or remove + not found
     NoMemError = 827
   };
-  STATIC_CONST( SignalLength = 7 );
+  STATIC_CONST( SignalLength = 8 );
 private:
   /*
    * Error code set by TUX.  Zero means no error.
@@ -52,10 +52,11 @@ private:
   Uint32 indexId;
   Uint32 fragId;
   /*
-   * Tuple version identified by logical address of "original" tuple and
-   * version number.
+   * Tuple version identified by physical address of "original" tuple
+   * and version number.
    */
-  Uint32 tupAddr;
+  Uint32 pageId;
+  Uint32 pageOffset;
   Uint32 tupVersion;
   /*
    * Operation code and flags.
diff --git a/ndb/src/common/debugger/signaldata/TuxMaint.cpp b/ndb/src/common/debugger/signaldata/TuxMaint.cpp
index 06ac475382c..ba6a299b77d 100644
--- a/ndb/src/common/debugger/signaldata/TuxMaint.cpp
+++ b/ndb/src/common/debugger/signaldata/TuxMaint.cpp
@@ -24,10 +24,10 @@ printTUX_MAINT_REQ(FILE* output, const Uint32* theData, Uint32 len, Uint16 rbn)
   //const bool inOut = rbn & (1 << 15);
   const TuxMaintReq* const sig = (const TuxMaintReq*)theData;
   fprintf(output, " errorCode=%d\n", sig->errorCode);
-  fprintf(output, " table: id=%d", sig->tableId);
-  fprintf(output, " index: id=%d", sig->indexId);
-  fprintf(output, " fragment: id=%d\n", sig->fragId);
-  fprintf(output, " tuple: addr=0x%x version=%d\n", sig->tupAddr, sig->tupVersion);
+  fprintf(output, " table: id=%u", sig->tableId);
+  fprintf(output, " index: id=%u", sig->indexId);
+  fprintf(output, " fragment: id=%u\n", sig->fragId);
+  fprintf(output, " tuple: loc=%u.%u version=%u\n", sig->pageId, sig->pageOffset, sig->tupVersion);
   const Uint32 opCode = sig->opInfo & 0xFF;
   const Uint32 opFlag = sig->opInfo >> 8;
   switch (opCode ) {
diff --git a/ndb/src/kernel/blocks/dbtup/Dbtup.hpp b/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
index f2ce54ec96c..70450c8277c 100644
--- a/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
+++ b/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
@@ -997,6 +997,11 @@ public:
   virtual ~Dbtup();
 
   /*
+   * TUX uses logical tuple address when talking to ACC and LQH.
+   */
+  void tuxGetTupAddr(Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32& tupAddr);
+
+  /*
    * TUX index in TUP has single Uint32 array attribute which stores an
    * index node.  TUX uses following methods.
    */
@@ -1004,6 +1009,13 @@ public:
   void tuxFreeNode(Signal* signal, Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32* node);
   void tuxGetNode(Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32*& node);
 
+  /*
+   * TUX reads primary table attributes for 1) index key 2) primary key
+   * when returning keyinfo.  TUX uses following methods.
+   */
+  void tuxReadAttrs();  // under construction
+  void tuxReadKeys();   // under construction
+
 private:
   BLOCK_DEFINES(Dbtup);
 
diff --git a/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp b/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp
index baa738a8c42..56d6b71f04d 100644
--- a/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp
+++ b/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp
@@ -31,6 +31,97 @@
 // methods used by ordered index
 
 void
+Dbtup::tuxGetTupAddr(Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32& tupAddr)
+{
+  FragrecordPtr fragPtr;
+  fragPtr.i = fragPtrI;
+  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
+  TablerecPtr tablePtr;
+  tablePtr.i = fragPtr.p->fragTableId;
+  ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
+  PagePtr pagePtr;
+  pagePtr.i = pageId;
+  ptrCheckGuard(pagePtr, cnoOfPage, page);
+  Uint32 fragPageId = pagePtr.p->pageWord[ZPAGE_FRAG_PAGE_ID_POS];
+  Uint32 tupheadsize = tablePtr.p->tupheadsize;
+  ndbrequire(pageOffset >= ZPAGE_HEADER_SIZE);
+  Uint32 offset = pageOffset - ZPAGE_HEADER_SIZE;
+  ndbrequire(offset % tupheadsize == 0);
+  Uint32 pageIndex = (offset / tupheadsize) << 1;
+  tupAddr = (fragPageId << MAX_TUPLES_BITS) | pageIndex;
+}
+
+int
+Dbtup::tuxAllocNode(Signal* signal, Uint32 fragPtrI, Uint32& pageId, Uint32& pageOffset, Uint32*& node)
+{
+  FragrecordPtr fragPtr;
+  fragPtr.i = fragPtrI;
+  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
+  TablerecPtr tablePtr;
+  tablePtr.i = fragPtr.p->fragTableId;
+  ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
+  PagePtr pagePtr;
+  terrorCode = 0;
+  if (! allocTh(fragPtr.p, tablePtr.p, NORMAL_PAGE, signal, pageOffset, pagePtr)) {
+    jam();
+    ndbrequire(terrorCode != 0);
+    return terrorCode;
+  }
+  pageId = pagePtr.i;
+  Uint32 attrDescIndex = tablePtr.p->tabDescriptor + (0 << ZAD_LOG_SIZE);
+  Uint32 attrDataOffset = AttributeOffset::getOffset(tableDescriptor[attrDescIndex + 1].tabDescr);
+  node = &pagePtr.p->pageWord[pageOffset] + attrDataOffset;
+  return 0;
+}
+
+void
+Dbtup::tuxFreeNode(Signal* signal, Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32* node)
+{
+  FragrecordPtr fragPtr;
+  fragPtr.i = fragPtrI;
+  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
+  TablerecPtr tablePtr;
+  tablePtr.i = fragPtr.p->fragTableId;
+  ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
+  PagePtr pagePtr;
+  pagePtr.i = pageId;
+  ptrCheckGuard(pagePtr, cnoOfPage, page);
+  Uint32 attrDescIndex = tablePtr.p->tabDescriptor + (0 << ZAD_LOG_SIZE);
+  Uint32 attrDataOffset = AttributeOffset::getOffset(tableDescriptor[attrDescIndex + 1].tabDescr);
+  ndbrequire(node == &pagePtr.p->pageWord[pageOffset] + attrDataOffset);
+  freeTh(fragPtr.p, tablePtr.p, signal, pagePtr.p, pageOffset);
+}
+
+void
+Dbtup::tuxGetNode(Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32*& node)
+{
+  FragrecordPtr fragPtr;
+  fragPtr.i = fragPtrI;
+  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
+  TablerecPtr tablePtr;
+  tablePtr.i = fragPtr.p->fragTableId;
+  ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
+  PagePtr pagePtr;
+  pagePtr.i = pageId;
+  ptrCheckGuard(pagePtr, cnoOfPage, page);
+  Uint32 attrDescIndex = tablePtr.p->tabDescriptor + (0 << ZAD_LOG_SIZE);
+  Uint32 attrDataOffset = AttributeOffset::getOffset(tableDescriptor[attrDescIndex + 1].tabDescr);
+  node = &pagePtr.p->pageWord[pageOffset] + attrDataOffset;
+}
+
+void    // under construction
+Dbtup::tuxReadAttrs()
+{
+}
+
+void    // under construction
+Dbtup::tuxReadKeys()
+{
+}
+
+// deprecated signal interfaces
+
+void
 Dbtup::execTUP_READ_ATTRS(Signal* signal)
 {
   ljamEntry();
@@ -179,64 +270,6 @@ Dbtup::execTUP_QUERY_TH(Signal* signal)
   return;
 }
 
-int
-Dbtup::tuxAllocNode(Signal* signal, Uint32 fragPtrI, Uint32& pageId, Uint32& pageOffset, Uint32*& node)
-{
-  FragrecordPtr fragPtr;
-  fragPtr.i = fragPtrI;
-  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
-  TablerecPtr tablePtr;
-  tablePtr.i = fragPtr.p->fragTableId;
-  ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
-  PagePtr pagePtr;
-  terrorCode = 0;
-  if (! allocTh(fragPtr.p, tablePtr.p, NORMAL_PAGE, signal, pageOffset, pagePtr)) {
-    jam();
-    ndbrequire(terrorCode != 0);
-    return terrorCode;
-  }
-  pageId = pagePtr.i;
-  Uint32 attrDescIndex = tablePtr.p->tabDescriptor + (0 << ZAD_LOG_SIZE);
-  Uint32 attrDataOffset = AttributeOffset::getOffset(tableDescriptor[attrDescIndex + 1].tabDescr);
-  node = &pagePtr.p->pageWord[pageOffset] + attrDataOffset;
-  return 0;
-}
-
-void
-Dbtup::tuxFreeNode(Signal* signal, Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32* node)
-{
-  FragrecordPtr fragPtr;
-  fragPtr.i = fragPtrI;
-  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
-  TablerecPtr tablePtr;
-  tablePtr.i = fragPtr.p->fragTableId;
-  ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
-  PagePtr pagePtr;
-  pagePtr.i = pageId;
-  ptrCheckGuard(pagePtr, cnoOfPage, page);
-  Uint32 attrDescIndex = tablePtr.p->tabDescriptor + (0 << ZAD_LOG_SIZE);
-  Uint32 attrDataOffset = AttributeOffset::getOffset(tableDescriptor[attrDescIndex + 1].tabDescr);
-  ndbrequire(node == &pagePtr.p->pageWord[pageOffset] + attrDataOffset);
-  freeTh(fragPtr.p, tablePtr.p, signal, pagePtr.p, pageOffset);
-}
-
-void
-Dbtup::tuxGetNode(Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32*& node)
-{
-  FragrecordPtr fragPtr;
-  fragPtr.i = fragPtrI;
-  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
-  TablerecPtr tablePtr;
-  tablePtr.i = fragPtr.p->fragTableId;
-  ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
-  PagePtr pagePtr;
-  pagePtr.i = pageId;
-  ptrCheckGuard(pagePtr, cnoOfPage, page);
-  Uint32 attrDescIndex = tablePtr.p->tabDescriptor + (0 << ZAD_LOG_SIZE);
-  Uint32 attrDataOffset = AttributeOffset::getOffset(tableDescriptor[attrDescIndex + 1].tabDescr);
-  node = &pagePtr.p->pageWord[pageOffset] + attrDataOffset;
-}
-
 void
 Dbtup::execTUP_STORE_TH(Signal* signal)
 {
@@ -483,7 +516,8 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
       buildPtr.p->m_tupleNo = 0;
       break;
     }
-    pagePtr.i = getRealpid(fragPtr.p, buildPtr.p->m_pageId);
+    Uint32 realPageId = getRealpid(fragPtr.p, buildPtr.p->m_pageId);
+    pagePtr.i = realPageId;
     ptrCheckGuard(pagePtr, cnoOfPage, page);
     const Uint32 pageState = pagePtr.p->pageWord[ZPAGE_STATE_POS];
     if (pageState != ZTH_MM_FREE &&
@@ -497,8 +531,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
     }
     // get tuple
     const Uint32 tupheadsize = tablePtr.p->tupheadsize;
-    const Uint32 pageOffset = ZPAGE_HEADER_SIZE +
-                              buildPtr.p->m_tupleNo * tupheadsize;
+    Uint32 pageOffset = ZPAGE_HEADER_SIZE + buildPtr.p->m_tupleNo * tupheadsize;
     if (pageOffset + tupheadsize > ZWORDS_ON_PAGE) {
       ljam();
       buildPtr.p->m_pageId++;
@@ -530,15 +563,14 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
       buildPtr.p->m_tupleNo++;
       break;
     }
+    Uint32 tupVersion = pagePtr.p->pageWord[pageOffset + 1];
     OperationrecPtr pageOperPtr;
     pageOperPtr.i = pagePtr.p->pageWord[pageOffset];
-    Uint32 pageId = buildPtr.p->m_pageId;
-    Uint32 pageIndex = buildPtr.p->m_tupleNo << 1;
     if (pageOperPtr.i != RNIL) {
       /*
       If there is an ongoing operation on the tuple then it is either a
       copy tuple or an original tuple with an ongoing transaction. In
-      both cases fragPageId and pageIndex refers to the original tuple.
+      both cases realPageId and pageOffset refer to the original tuple.
       The tuple address stored in TUX will always be the original tuple
       but with the tuple version of the tuple we found.
 
@@ -550,10 +582,9 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
       */
       jam();
       ptrCheckGuard(pageOperPtr, cnoOfOprec, operationrec);
-      pageId = pageOperPtr.p->fragPageId;
-      pageIndex = pageOperPtr.p->pageIndex;
+      realPageId = pageOperPtr.p->realPageId;
+      pageOffset = pageOperPtr.p->pageOffset;
     }//if
-    Uint32 tup_version = pagePtr.p->pageWord[pageOffset + 1];
 #ifdef TIME_MEASUREMENT
     NdbTick_getMicroTimer(&start);
 #endif
@@ -563,8 +594,9 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
     req->tableId = tablePtr.i;
     req->indexId = triggerPtr.p->indexId;
     req->fragId = tablePtr.p->fragid[buildPtr.p->m_fragNo];
-    req->tupAddr = (pageId << MAX_TUPLES_BITS) | pageIndex;
-    req->tupVersion = tup_version;
+    req->pageId = realPageId;
+    req->pageOffset = pageOffset;
+    req->tupVersion = tupVersion;
     req->opInfo = TuxMaintReq::OpAdd;
     EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ,
         signal, TuxMaintReq::SignalLength);
diff --git a/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp b/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp
index 6fceea31150..a93ff4566e7 100644
--- a/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp
+++ b/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp
@@ -962,7 +962,8 @@ Dbtup::executeTuxInsertTriggers(Signal* signal,
   // fill in constant part
   req->tableId = regOperPtr->tableRef;
   req->fragId = regOperPtr->fragId;
-  req->tupAddr = (regOperPtr->fragPageId << MAX_TUPLES_BITS) | regOperPtr->pageIndex;
+  req->pageId = regOperPtr->realPageId;
+  req->pageOffset = regOperPtr->pageOffset;
   req->tupVersion = tupVersion;
   req->opInfo = TuxMaintReq::OpAdd;
   // loop over index list
@@ -1000,7 +1001,8 @@ Dbtup::executeTuxUpdateTriggers(Signal* signal,
   // fill in constant part
   req->tableId = regOperPtr->tableRef;
   req->fragId = regOperPtr->fragId;
-  req->tupAddr = (regOperPtr->fragPageId << MAX_TUPLES_BITS) | regOperPtr->pageIndex;
+  req->pageId = regOperPtr->realPageId;
+  req->pageOffset = regOperPtr->pageOffset;
   req->tupVersion = tupVersion;
   req->opInfo = TuxMaintReq::OpAdd;
   // loop over index list
@@ -1009,7 +1011,6 @@ Dbtup::executeTuxUpdateTriggers(Signal* signal,
   triggerList.first(triggerPtr);
   while (triggerPtr.i != RNIL) {
     ljam();
-    req->tupAddr = (regOperPtr->fragPageId << MAX_TUPLES_BITS) | regOperPtr->pageIndex;
     req->indexId = triggerPtr.p->indexId;
     req->errorCode = RNIL;
     EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ,
@@ -1074,7 +1075,8 @@ Dbtup::executeTuxCommitTriggers(Signal* signal,
   // fill in constant part
   req->tableId = regOperPtr->tableRef;
   req->fragId = regOperPtr->fragId;
-  req->tupAddr = (regOperPtr->fragPageId << MAX_TUPLES_BITS) | regOperPtr->pageIndex;
+  req->pageId = regOperPtr->realPageId;
+  req->pageOffset = regOperPtr->pageOffset;
   req->tupVersion = tupVersion;
   req->opInfo = TuxMaintReq::OpRemove;
   // loop over index list
@@ -1117,7 +1119,8 @@ Dbtup::executeTuxAbortTriggers(Signal* signal,
   // fill in constant part
   req->tableId = regOperPtr->tableRef;
   req->fragId = regOperPtr->fragId;
-  req->tupAddr = (regOperPtr->fragPageId << MAX_TUPLES_BITS) | regOperPtr->pageIndex;
+  req->pageId = regOperPtr->realPageId;
+  req->pageOffset = regOperPtr->pageOffset;
   req->tupVersion = tupVersion;
   req->opInfo = TuxMaintReq::OpRemove;
   // loop over index list
diff --git a/ndb/src/kernel/blocks/dbtux/Dbtux.hpp b/ndb/src/kernel/blocks/dbtux/Dbtux.hpp
index dba778ccebe..a3268c81cd4 100644
--- a/ndb/src/kernel/blocks/dbtux/Dbtux.hpp
+++ b/ndb/src/kernel/blocks/dbtux/Dbtux.hpp
@@ -183,17 +183,17 @@ private:
   // tree definitions
 
   /*
-   * Tree entry.  Points to a tuple in primary table via logical address
-   * of "original" tuple and tuple version.  Uses 2 words to get correct
-   * aligment (one byte is wasted currently).
+   * Tree entry.  Points to a tuple in primary table via physical
+   * address of "original" tuple and tuple version.
+   *
+   * ZTUP_VERSION_BITS must be 15 (or less).
    */
   struct TreeEnt;
   friend struct TreeEnt;
   struct TreeEnt {
-    TupAddr m_tupAddr;          // address of original tuple
-    Uint16 m_tupVersion;        // version
-    Uint8 m_fragBit;            // which duplicated table fragment
-    Uint8 pad1;
+    TupLoc m_tupLoc;            // address of original tuple
+    unsigned m_tupVersion : 15; // version
+    unsigned m_fragBit : 1;     // which duplicated table fragment
     TreeEnt();
     // methods
     int cmp(const TreeEnt ent) const;
@@ -318,10 +318,9 @@ private:
    * Attribute metadata.  Size must be multiple of word size.
    */
   struct DescAttr {
-    unsigned m_primaryAttrId : 16;
-    unsigned m_typeId : 8;
-    unsigned m_nullable : 1;
-    unsigned pad1 : 7;
+    Uint32 m_attrDesc;          // standard AttributeDescriptor
+    Uint16 m_primaryAttrId;
+    Uint16 m_typeId;
   };
   static const unsigned DescAttrSize = sizeof(DescAttr) >> 2;
 
@@ -615,8 +614,6 @@ private:
   bool allocDescEnt(IndexPtr indexPtr);
   void freeDescEnt(IndexPtr indexPtr);
   void dropIndex(Signal* signal, IndexPtr indexPtr, Uint32 senderRef, Uint32 senderData);
-  // helpers
-  DescEnt& getDescEnt(Uint32 descPage, Uint32 descOff);
 
   /*
    * DbtuxMaint.cpp
@@ -722,7 +719,9 @@ private:
   // buffers
   Data c_keyBuffer;             // search key or scan bound
 
-  // small stuff
+  // inlined utils
+  DescEnt& getDescEnt(Uint32 descPage, Uint32 descOff);
+  Uint32 getTupAddr(const Frag& frag, const TreeEnt ent);
   static unsigned min(unsigned x, unsigned y);
   static unsigned max(unsigned x, unsigned y);
 };
@@ -852,24 +851,26 @@ Dbtux::TupLoc::operator!=(const TupLoc& loc) const
 
 inline
 Dbtux::TreeEnt::TreeEnt() :
-  m_tupAddr(NullTupAddr),
+  m_tupLoc(),
   m_tupVersion(0),
-  m_fragBit(255),
-  pad1(0)
+  m_fragBit(0)
 {
 }
 
 inline int
 Dbtux::TreeEnt::cmp(const TreeEnt ent) const
 {
-  // compare frags first (not optimal but makes easier to read logs)
   if (m_fragBit < ent.m_fragBit)
     return -1;
   if (m_fragBit > ent.m_fragBit)
     return +1;
-  if (m_tupAddr < ent.m_tupAddr)
+  if (m_tupLoc.m_pageId < ent.m_tupLoc.m_pageId)
+    return -1;
+  if (m_tupLoc.m_pageId > ent.m_tupLoc.m_pageId)
+    return +1;
+  if (m_tupLoc.m_pageOffset < ent.m_tupLoc.m_pageOffset)
     return -1;
-  if (m_tupAddr > ent.m_tupAddr)
+  if (m_tupLoc.m_pageOffset > ent.m_tupLoc.m_pageOffset)
     return +1;
   if (m_tupVersion < ent.m_tupVersion)
     return -1;
@@ -1252,7 +1253,7 @@ Dbtux::PrintPar::PrintPar() :
 }
 #endif
 
-// other methods
+// utils
 
 inline Dbtux::DescEnt&
 Dbtux::getDescEnt(Uint32 descPage, Uint32 descOff)
@@ -1265,6 +1266,16 @@ Dbtux::getDescEnt(Uint32 descPage, Uint32 descOff)
   return *descEnt;
 }
 
+inline Uint32
+Dbtux::getTupAddr(const Frag& frag, const TreeEnt ent)
+{
+  const Uint32 tableFragPtrI = frag.m_tupTableFragPtrI[ent.m_fragBit];
+  const TupLoc tupLoc = ent.m_tupLoc;
+  Uint32 tupAddr = NullTupAddr;
+  c_tup->tuxGetTupAddr(tableFragPtrI, tupLoc.m_pageId, tupLoc.m_pageOffset, tupAddr);
+  return tupAddr;
+}
+
 inline unsigned
 Dbtux::min(unsigned x, unsigned y)
 {
diff --git a/ndb/src/kernel/blocks/dbtux/DbtuxDebug.cpp b/ndb/src/kernel/blocks/dbtux/DbtuxDebug.cpp
index 11411c886be..c4931685305 100644
--- a/ndb/src/kernel/blocks/dbtux/DbtuxDebug.cpp
+++ b/ndb/src/kernel/blocks/dbtux/DbtuxDebug.cpp
@@ -198,7 +198,7 @@ operator<<(NdbOut& out, const Dbtux::TupLoc& loc)
   if (loc == Dbtux::NullTupLoc) {
     out << "null";
   } else {
-    out << hex << loc.m_pageId;
+    out << dec << loc.m_pageId;
     out << "." << dec << loc.m_pageOffset;
   }
   return out;
@@ -208,7 +208,7 @@ NdbOut&
 operator<<(NdbOut& out, const Dbtux::TreeEnt& ent)
 {
   out << dec << ent.m_fragBit;
-  out << "-" << hex << ent.m_tupAddr;
+  out << "-" << ent.m_tupLoc;
   out << "-" << dec << ent.m_tupVersion;
   return out;
 }
@@ -264,9 +264,9 @@ NdbOut&
 operator<<(NdbOut& out, const Dbtux::DescAttr& descAttr)
 {
   out << "[DescAttr " << hex << &descAttr;
+  out << " [attrDesc " << hex << descAttr.m_attrDesc;
   out << " [primaryAttrId " << dec << descAttr.m_primaryAttrId << "]";
   out << " [typeId " << dec << descAttr.m_typeId << "]";
-  out << " [nullable " << dec << descAttr.m_nullable << "]";
   out << "]";
   return out;
 }
diff --git a/ndb/src/kernel/blocks/dbtux/DbtuxGen.cpp b/ndb/src/kernel/blocks/dbtux/DbtuxGen.cpp
index 788d29f3bce..72d7090ddc6 100644
--- a/ndb/src/kernel/blocks/dbtux/DbtuxGen.cpp
+++ b/ndb/src/kernel/blocks/dbtux/DbtuxGen.cpp
@@ -35,10 +35,10 @@ Dbtux::Dbtux(const Configuration& conf) :
   BLOCK_CONSTRUCTOR(Dbtux);
   // verify size assumptions (also when release-compiled)
   ndbrequire(
-      (sizeof(DescHead) & 0x3) == 0 &&
-      (sizeof(DescAttr) & 0x3) == 0 &&
       (sizeof(TreeEnt) & 0x3) == 0 &&
-      (sizeof(TreeNode) & 0x3) == 0
+      (sizeof(TreeNode) & 0x3) == 0 &&
+      (sizeof(DescHead) & 0x3) == 0 &&
+      (sizeof(DescAttr) & 0x3) == 0
   );
   /*
    * DbtuxGen.cpp
diff --git a/ndb/src/kernel/blocks/dbtux/DbtuxMaint.cpp b/ndb/src/kernel/blocks/dbtux/DbtuxMaint.cpp
index e674cdfca74..2b1e9620ea1 100644
--- a/ndb/src/kernel/blocks/dbtux/DbtuxMaint.cpp
+++ b/ndb/src/kernel/blocks/dbtux/DbtuxMaint.cpp
@@ -33,11 +33,12 @@ Dbtux::execTUX_MAINT_REQ(Signal* signal)
     jam();
 #ifdef VM_TRACE
     if (debugFlags & DebugMaint) {
+      TupLoc tupLoc(sig->pageId, sig->pageOffset);
       debugOut << "opInfo=" << hex << sig->opInfo;
       debugOut << " tableId=" << dec << sig->tableId;
       debugOut << " indexId=" << dec << sig->indexId;
       debugOut << " fragId=" << dec << sig->fragId;
-      debugOut << " tupAddr=" << hex << sig->tupAddr;
+      debugOut << " tupLoc=" << tupLoc;
       debugOut << " tupVersion=" << dec << sig->tupVersion;
       debugOut << " -- ignored at ISP=" << dec << c_internalStartPhase;
       debugOut << " TOS=" << dec << c_typeOfStart;
@@ -74,7 +75,7 @@ Dbtux::execTUX_MAINT_REQ(Signal* signal)
   Frag& frag = *fragPtr.p;
   // set up index entry
   TreeEnt ent;
-  ent.m_tupAddr = req->tupAddr;
+  ent.m_tupLoc = TupLoc(req->pageId, req->pageOffset);
   ent.m_tupVersion = req->tupVersion;
   ent.m_fragBit = fragBit;
   // read search key
@@ -199,10 +200,10 @@ Dbtux::tupReadAttrs(Signal* signal, const Frag& frag, ReadPar& readPar)
   req->tableId = frag.m_tableId;
   req->fragId = frag.m_fragId | (ent.m_fragBit << frag.m_fragOff);
   req->fragPtrI = frag.m_tupTableFragPtrI[ent.m_fragBit];
-  req->tupAddr = ent.m_tupAddr;
+  req->tupAddr = (Uint32)-1;
   req->tupVersion = ent.m_tupVersion;
-  req->pageId = RNIL;
-  req->pageOffset = 0;
+  req->pageId = ent.m_tupLoc.m_pageId;
+  req->pageOffset = ent.m_tupLoc.m_pageOffset;
   req->bufferId = 0;
   // add count and list of attribute ids
   Data data = (Uint32*)req + TupReadAttrs::SignalLength;
@@ -246,10 +247,10 @@ Dbtux::tupReadKeys(Signal* signal, const Frag& frag, ReadPar& readPar)
   req->tableId = frag.m_tableId;
   req->fragId = frag.m_fragId | (ent.m_fragBit << frag.m_fragOff);
   req->fragPtrI = frag.m_tupTableFragPtrI[ent.m_fragBit];
-  req->tupAddr = ent.m_tupAddr;
+  req->tupAddr = (Uint32)-1;
   req->tupVersion = RNIL; // not used
-  req->pageId = RNIL;
-  req->pageOffset = 0;
+  req->pageId = ent.m_tupLoc.m_pageId;
+  req->pageOffset = ent.m_tupLoc.m_pageOffset;
   req->bufferId = 0;
   // execute
   EXECUTE_DIRECT(DBTUP, GSN_TUP_READ_ATTRS, signal, TupReadAttrs::SignalLength);
diff --git a/ndb/src/kernel/blocks/dbtux/DbtuxMeta.cpp b/ndb/src/kernel/blocks/dbtux/DbtuxMeta.cpp
index 9e17f182798..0612f191830 100644
--- a/ndb/src/kernel/blocks/dbtux/DbtuxMeta.cpp
+++ b/ndb/src/kernel/blocks/dbtux/DbtuxMeta.cpp
@@ -181,10 +181,9 @@ Dbtux::execTUX_ADD_ATTRREQ(Signal* signal)
     // define the attribute
     DescEnt& descEnt = getDescEnt(indexPtr.p->m_descPage, indexPtr.p->m_descOff);
     DescAttr& descAttr = descEnt.m_descAttr[attrId];
+    descAttr.m_attrDesc = req->attrDescriptor;
     descAttr.m_primaryAttrId = req->primaryAttrId;
     descAttr.m_typeId = req->extTypeInfo & 0xFF;
-    descAttr.m_nullable = AttributeDescriptor::getNullable(req->attrDescriptor);
-    descAttr.pad1 = 0;
 #ifdef VM_TRACE
     if (debugFlags & DebugMeta) {
       debugOut << "Add frag " << fragPtr.i << " attr " << attrId << " " << descAttr << endl;
diff --git a/ndb/src/kernel/blocks/dbtux/DbtuxScan.cpp b/ndb/src/kernel/blocks/dbtux/DbtuxScan.cpp
index 7baea224c93..e265406002a 100644
--- a/ndb/src/kernel/blocks/dbtux/DbtuxScan.cpp
+++ b/ndb/src/kernel/blocks/dbtux/DbtuxScan.cpp
@@ -406,7 +406,7 @@ Dbtux::execACC_CHECK_SCAN(Signal* signal)
       const Uint32* const buf32 = static_cast<Uint32*>(keyPar.m_data);
       const Uint64* const buf64 = reinterpret_cast<const Uint64*>(buf32);
       lockReq->hashValue = md5_hash(buf64, keyPar.m_size);
-      lockReq->tupAddr = ent.m_tupAddr;
+      lockReq->tupAddr = getTupAddr(frag, ent);
       lockReq->transId1 = scan.m_transId1;
       lockReq->transId2 = scan.m_transId2;
       // execute
@@ -503,7 +503,7 @@ Dbtux::execACC_CHECK_SCAN(Signal* signal)
     }
     conf->accOperationPtr = accLockOp;
     conf->fragId = frag.m_fragId | (ent.m_fragBit << frag.m_fragOff);
-    conf->localKey[0] = ent.m_tupAddr;
+    conf->localKey[0] = getTupAddr(frag, ent);
     conf->localKey[1] = 0;
     conf->localKeyLength = 1;
     unsigned signalLength = 6;
@@ -1001,10 +1001,10 @@ Dbtux::scanVisible(Signal* signal, ScanOpPtr scanPtr, TreeEnt ent)
   Uint32 tableId = frag.m_tableId;
   Uint32 fragBit = ent.m_fragBit;
   Uint32 fragId = frag.m_fragId | (fragBit << frag.m_fragOff);
-  Uint32 tupAddr = ent.m_tupAddr;
+  Uint32 tupAddr = getTupAddr(frag, ent);
   Uint32 tupVersion = ent.m_tupVersion;
   /* Check for same tuple twice in row */
-  if (scan.m_lastEnt.m_tupAddr == tupAddr &&
+  if (scan.m_lastEnt.m_tupLoc == ent.m_tupLoc &&
       scan.m_lastEnt.m_fragBit == fragBit) {
     jam();
     return false;
diff --git a/ndb/src/kernel/blocks/dbtux/Times.txt b/ndb/src/kernel/blocks/dbtux/Times.txt
index 78e35804b9d..6e3caec0048 100644
--- a/ndb/src/kernel/blocks/dbtux/Times.txt
+++ b/ndb/src/kernel/blocks/dbtux/Times.txt
@@ -34,4 +34,11 @@ optim 5         mc02/a  43 ms   77 ms    77 pct
 optim 6         mc02/a  42 ms   70 ms    66 pct
                 mc02/b  53 ms  109 ms   105 pct
 
+optim 7         mc02/a  42 ms   69 ms    61 pct
+                mc02/b  52 ms  106 ms   101 pct
+
+optim 8         mc02/a  42 ms   69 ms    62 pct
+                mc02/b  54 ms  104 ms    92 pct
+
+
 vim: set et: