Merge tulin@bk-internal.mysql.com:/home/bk/mysql-5.0

into  poseidon.ndb.mysql.com:/home/tomas/mysql-5.0-main


mysql-test/mysql-test-run.sh:
  Auto merged
ndb/include/kernel/GlobalSignalNumbers.h:
  Auto merged
ndb/src/kernel/blocks/dbdict/Dbdict.cpp:
  Auto merged
ndb/src/kernel/blocks/dbdict/Dbdict.hpp:
  Auto merged
sql/ha_ndbcluster.cc:
  Auto merged

31 files changed, 563 insertions, 139 deletions

diff --git a/ndb/include/kernel/GlobalSignalNumbers.h b/ndb/include/kernel/GlobalSignalNumbers.h
index d60f7a2c582..ca82806f4b1 100644
--- a/ndb/include/kernel/GlobalSignalNumbers.h
+++ b/ndb/include/kernel/GlobalSignalNumbers.h
@@ -607,8 +607,6 @@ extern const GlobalSignalNumber NO_OF_SIGNAL_NAMES;
 #define GSN_WAIT_GCP_REF                500
 #define GSN_WAIT_GCP_CONF               501
 
-/* 502 not used */
-
 /**
  * Trigger and index signals
  */
@@ -678,6 +676,8 @@ extern const GlobalSignalNumber NO_OF_SIGNAL_NAMES;
 #define GSN_BACKUP_FRAGMENT_REF         546
 #define GSN_BACKUP_FRAGMENT_CONF        547
 
+#define GSN_BACKUP_FRAGMENT_COMPLETE_REP 575
+
 #define GSN_STOP_BACKUP_REQ             548
 #define GSN_STOP_BACKUP_REF             549
 #define GSN_STOP_BACKUP_CONF            550
@@ -727,7 +727,7 @@ extern const GlobalSignalNumber NO_OF_SIGNAL_NAMES;
 #define GSN_SUB_STOP_REQ                572
 #define GSN_SUB_STOP_REF                573
 #define GSN_SUB_STOP_CONF               574
-/*                                      575 unused */
+/*                                      575 used */
 #define GSN_SUB_CREATE_REQ              576
 #define GSN_SUB_CREATE_REF              577
 #define GSN_SUB_CREATE_CONF             578
diff --git a/ndb/include/kernel/signaldata/BackupContinueB.hpp b/ndb/include/kernel/signaldata/BackupContinueB.hpp
index d3d3f79f310..fe3f48444ec 100644
--- a/ndb/include/kernel/signaldata/BackupContinueB.hpp
+++ b/ndb/include/kernel/signaldata/BackupContinueB.hpp
@@ -31,7 +31,8 @@ private:
     BUFFER_UNDERFLOW  = 1,
     BUFFER_FULL_SCAN  = 2,
     BUFFER_FULL_FRAG_COMPLETE = 3,
-    BUFFER_FULL_META  = 4
+    BUFFER_FULL_META  = 4,
+    BACKUP_FRAGMENT_INFO = 5
   };
 };
 
diff --git a/ndb/include/kernel/signaldata/BackupImpl.hpp b/ndb/include/kernel/signaldata/BackupImpl.hpp
index 298440ad377..07ab5bc543b 100644
--- a/ndb/include/kernel/signaldata/BackupImpl.hpp
+++ b/ndb/include/kernel/signaldata/BackupImpl.hpp
@@ -258,15 +258,31 @@ class BackupFragmentConf {
 
   friend bool printBACKUP_FRAGMENT_CONF(FILE *, const Uint32 *, Uint32, Uint16);
 public:
-  STATIC_CONST( SignalLength = 6 );
+  STATIC_CONST( SignalLength = 8 );
 
 private:
   Uint32 backupId;
   Uint32 backupPtr;
   Uint32 tableId;
   Uint32 fragmentNo;
-  Uint32 noOfRecords;
-  Uint32 noOfBytes;
+  Uint32 noOfRecordsLow;
+  Uint32 noOfBytesLow;
+  Uint32 noOfRecordsHigh;
+  Uint32 noOfBytesHigh;
+};
+
+class BackupFragmentCompleteRep {
+public:
+  STATIC_CONST( SignalLength = 8 );
+
+  Uint32 backupId;
+  Uint32 backupPtr;
+  Uint32 tableId;
+  Uint32 fragmentNo;
+  Uint32 noOfTableRowsLow;
+  Uint32 noOfFragmentRowsLow;
+  Uint32 noOfTableRowsHigh;
+  Uint32 noOfFragmentRowsHigh;
 };
 
 class StopBackupReq {
diff --git a/ndb/include/kernel/signaldata/BackupSignalData.hpp b/ndb/include/kernel/signaldata/BackupSignalData.hpp
index e1b8c6203a1..9e34ea3a211 100644
--- a/ndb/include/kernel/signaldata/BackupSignalData.hpp
+++ b/ndb/include/kernel/signaldata/BackupSignalData.hpp
@@ -201,17 +201,19 @@ class BackupCompleteRep {
 
   friend bool printBACKUP_COMPLETE_REP(FILE *, const Uint32 *, Uint32, Uint16);
 public:
-  STATIC_CONST( SignalLength = 8 + NdbNodeBitmask::Size );
+  STATIC_CONST( SignalLength = 10 + NdbNodeBitmask::Size );
 private:
   Uint32 senderData;
   Uint32 backupId;
   Uint32 startGCP;
   Uint32 stopGCP;
-  Uint32 noOfBytes;
-  Uint32 noOfRecords;
+  Uint32 noOfBytesLow;
+  Uint32 noOfRecordsLow;
   Uint32 noOfLogBytes;
   Uint32 noOfLogRecords;
   NdbNodeBitmask nodes;
+  Uint32 noOfBytesHigh;
+  Uint32 noOfRecordsHigh;
 };
 
 /**
diff --git a/ndb/include/kernel/signaldata/DictTabInfo.hpp b/ndb/include/kernel/signaldata/DictTabInfo.hpp
index bc4817f0cf3..0a7f6aa3fb3 100644
--- a/ndb/include/kernel/signaldata/DictTabInfo.hpp
+++ b/ndb/include/kernel/signaldata/DictTabInfo.hpp
@@ -117,9 +117,16 @@ public:
     CustomTriggerId    = 25,
     FrmLen             = 26,
     FrmData            = 27,
+
     FragmentCount      = 128, // No of fragments in table (!fragment replicas)
     FragmentDataLen    = 129,
     FragmentData       = 130, // CREATE_FRAGMENTATION reply
+
+    MaxRowsLow         = 139,
+    MaxRowsHigh        = 140,
+    MinRowsLow         = 143,
+    MinRowsHigh        = 144,
+
     TableEnd           = 999,
     
     AttributeName          = 1000, // String, Mandatory
@@ -263,6 +270,10 @@ public:
     Uint32 FragmentCount;
     Uint32 FragmentDataLen;
     Uint16 FragmentData[(MAX_FRAGMENT_DATA_BYTES+1)/2];
+    Uint32 MaxRowsLow;
+    Uint32 MaxRowsHigh;
+    Uint32 MinRowsLow;
+    Uint32 MinRowsHigh;
     
     void init();
   };
diff --git a/ndb/include/kernel/signaldata/LqhFrag.hpp b/ndb/include/kernel/signaldata/LqhFrag.hpp
index 13dfafcc653..50b0caaba07 100644
--- a/ndb/include/kernel/signaldata/LqhFrag.hpp
+++ b/ndb/include/kernel/signaldata/LqhFrag.hpp
@@ -104,7 +104,7 @@ class LqhFragReq {
   friend bool printLQH_FRAG_REQ(FILE *, const Uint32 *, Uint32, Uint16);
 
 public:
-  STATIC_CONST( SignalLength = 25 );
+  STATIC_CONST( SignalLength = 24 );
   
   enum RequestInfo {
     CreateInRunning = 0x8000000,
@@ -115,27 +115,32 @@ private:
   Uint32 senderData;
   Uint32 senderRef;
   Uint32 fragmentId;
-  Uint32 requestInfo; 
+  Uint8  requestInfo; 
+  Uint8  unused1; 
+  Uint16 noOfAttributes;
   Uint32 tableId;
   Uint32 localKeyLength;
-  Uint32 maxLoadFactor;
-  Uint32 minLoadFactor;
-  Uint32 kValue;
+  Uint16 maxLoadFactor;
+  Uint16 minLoadFactor;
+  Uint16 kValue;
+  Uint8  tableType;             // DictTabInfo::TableType
+  Uint8  GCPIndicator;
   Uint32 lh3DistrBits;
   Uint32 lh3PageBits;
-  Uint32 noOfAttributes;
   Uint32 noOfNullAttributes;
-  Uint32 noOfPagesToPreAllocate;
+  Uint32 maxRowsLow;
+  Uint32 maxRowsHigh;
+  Uint32 minRowsLow;
+  Uint32 minRowsHigh;
   Uint32 schemaVersion;
   Uint32 keyLength;
   Uint32 nextLCP;
   Uint32 noOfKeyAttr;
-  Uint32 noOfNewAttr;           // noOfCharsets in upper half
+  Uint16 noOfNewAttr;
+  Uint16 noOfCharsets;
   Uint32 checksumIndicator;
   Uint32 noOfAttributeGroups;
-  Uint32 GCPIndicator;
   Uint32 startGci;
-  Uint32 tableType;             // DictTabInfo::TableType
   Uint32 primaryTableId;        // table of index or RNIL
 };
 
diff --git a/ndb/include/kernel/signaldata/TupFrag.hpp b/ndb/include/kernel/signaldata/TupFrag.hpp
index 5fb9d7bcf42..c9f2ad5382f 100644
--- a/ndb/include/kernel/signaldata/TupFrag.hpp
+++ b/ndb/include/kernel/signaldata/TupFrag.hpp
@@ -30,7 +30,7 @@ class TupFragReq {
   friend class Dblqh;
   friend class Dbtup;
 public:
-  STATIC_CONST( SignalLength = 14 );
+  STATIC_CONST( SignalLength = 17 );
 private:
   Uint32 userPtr;
   Uint32 userRef;
@@ -38,7 +38,18 @@ private:
   Uint32 tableId;
   Uint32 noOfAttr;
   Uint32 fragId;
-  Uint32 todo[8];
+  Uint32 maxRowsLow;
+  Uint32 maxRowsHigh;
+  Uint32 minRowsLow;
+  Uint32 minRowsHigh;
+  Uint32 noOfNullAttr;
+  Uint32 schemaVersion;
+  Uint32 noOfKeyAttr;
+  Uint16 noOfNewAttr;
+  Uint16 noOfCharsets;
+  Uint32 checksumIndicator;
+  Uint32 noOfAttributeGroups;
+  Uint32 globalCheckpointIdIndicator;
 };
 
 class TupFragConf {
diff --git a/ndb/include/ndbapi/NdbDictionary.hpp b/ndb/include/ndbapi/NdbDictionary.hpp
index 1413931035d..e67a0253096 100644
--- a/ndb/include/ndbapi/NdbDictionary.hpp
+++ b/ndb/include/ndbapi/NdbDictionary.hpp
@@ -722,6 +722,20 @@ public:
      */
     void setObjectType(Object::Type type);
 
+    /**
+     * Set/Get Maximum number of rows in table (only used to calculate
+     * number of partitions).
+     */
+    void setMaxRows(Uint64 maxRows);
+    Uint64 getMaxRows() const;
+
+    /**
+     * Set/Get Minimum number of rows in table (only used to calculate
+     * number of partitions).
+     */
+    void setMinRows(Uint64 minRows);
+    Uint64 getMinRows() const;
+
     /** @} *******************************************************************/
 
 #ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
diff --git a/ndb/src/common/debugger/signaldata/BackupImpl.cpp b/ndb/src/common/debugger/signaldata/BackupImpl.cpp
index e9b0188d93b..855db0834bc 100644
--- a/ndb/src/common/debugger/signaldata/BackupImpl.cpp
+++ b/ndb/src/common/debugger/signaldata/BackupImpl.cpp
@@ -100,8 +100,10 @@ printBACKUP_FRAGMENT_CONF(FILE * out, const Uint32 * data, Uint32 l, Uint16 b){
   BackupFragmentConf* sig = (BackupFragmentConf*)data;
   fprintf(out, " backupPtr: %d backupId: %d\n",
 	  sig->backupPtr, sig->backupId);
-  fprintf(out, " tableId: %d fragmentNo: %d records: %d bytes: %d\n",
-	  sig->tableId, sig->fragmentNo, sig->noOfRecords, sig->noOfBytes);
+  fprintf(out, " tableId: %d fragmentNo: %d records: %llu bytes: %llu\n",
+	  sig->tableId, sig->fragmentNo,
+          sig->noOfRecordsLow + (((Uint64)sig->noOfRecordsHigh) << 32),
+          sig->noOfBytesLow + (((Uint64)sig->noOfBytesHigh) << 32));
   return true;
 }
 
diff --git a/ndb/src/common/debugger/signaldata/BackupSignalData.cpp b/ndb/src/common/debugger/signaldata/BackupSignalData.cpp
index 4b0a0e07b66..27fed22ac72 100644
--- a/ndb/src/common/debugger/signaldata/BackupSignalData.cpp
+++ b/ndb/src/common/debugger/signaldata/BackupSignalData.cpp
@@ -72,11 +72,11 @@ printBACKUP_ABORT_REP(FILE * out, const Uint32 * data, Uint32 len, Uint16 bno){
 bool 
 printBACKUP_COMPLETE_REP(FILE * out, const Uint32 * data, Uint32 len, Uint16 b){
   BackupCompleteRep* sig = (BackupCompleteRep*)data;
-  fprintf(out, " senderData: %d backupId: %d records: %d bytes: %d\n",
+  fprintf(out, " senderData: %d backupId: %d records: %llu bytes: %llu\n",
 	  sig->senderData,
 	  sig->backupId,
-	  sig->noOfRecords,
-	  sig->noOfBytes);
+	  sig->noOfRecordsLow + (((Uint64)sig->noOfRecordsHigh) << 32),
+          sig->noOfBytesLow + (((Uint64)sig->noOfBytesHigh) << 32));
   return true;
 }
 
diff --git a/ndb/src/common/debugger/signaldata/DictTabInfo.cpp b/ndb/src/common/debugger/signaldata/DictTabInfo.cpp
index 43c129347c0..a1d8d82474d 100644
--- a/ndb/src/common/debugger/signaldata/DictTabInfo.cpp
+++ b/ndb/src/common/debugger/signaldata/DictTabInfo.cpp
@@ -48,6 +48,10 @@ DictTabInfo::TableMapping[] = {
   DTIMAP(Table, FragmentCount, FragmentCount),
   DTIMAP2(Table, FragmentDataLen, FragmentDataLen, 0, MAX_FRAGMENT_DATA_BYTES),
   DTIMAPB(Table, FragmentData, FragmentData, 0, MAX_FRAGMENT_DATA_BYTES, FragmentDataLen),
+  DTIMAP(Table, MaxRowsLow, MaxRowsLow),
+  DTIMAP(Table, MaxRowsHigh, MaxRowsHigh),
+  DTIMAP(Table, MinRowsLow, MinRowsLow),
+  DTIMAP(Table, MinRowsHigh, MinRowsHigh),
   DTIBREAK(AttributeName)
 };
 
@@ -124,6 +128,10 @@ DictTabInfo::Table::init(){
   FragmentCount = 0;
   FragmentDataLen = 0;
   memset(FragmentData, 0, sizeof(FragmentData));
+  MaxRowsLow = 0;
+  MaxRowsHigh = 0;
+  MinRowsLow = 0;
+  MinRowsHigh = 0;
 }
 
 void
diff --git a/ndb/src/common/debugger/signaldata/LqhFrag.cpp b/ndb/src/common/debugger/signaldata/LqhFrag.cpp
index 6d727959a67..3175582c3a2 100644
--- a/ndb/src/common/debugger/signaldata/LqhFrag.cpp
+++ b/ndb/src/common/debugger/signaldata/LqhFrag.cpp
@@ -37,8 +37,10 @@ printLQH_FRAG_REQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 recB
   fprintf(output, " noOfAttributes: %d noOfNullAttributes: %d keyLength: %d\n",
 	  sig->noOfAttributes, sig->noOfNullAttributes, sig->keyLength);
 
-  fprintf(output, " noOfPagesToPreAllocate: %d schemaVersion: %d nextLCP: %d\n",
-	  sig->noOfPagesToPreAllocate, sig->schemaVersion, sig->nextLCP);
+  fprintf(output, " maxRowsLow/High: %u/%u  minRowsLow/High: %u/%u\n",
+	  sig->maxRowsLow, sig->maxRowsHigh, sig->minRowsLow, sig->minRowsHigh);
+  fprintf(output, " schemaVersion: %d nextLCP: %d\n",
+	  sig->schemaVersion, sig->nextLCP);
   
   return true;
 }
diff --git a/ndb/src/kernel/blocks/backup/Backup.cpp b/ndb/src/kernel/blocks/backup/Backup.cpp
index f9089355475..43c1de5e2b3 100644
--- a/ndb/src/kernel/blocks/backup/Backup.cpp
+++ b/ndb/src/kernel/blocks/backup/Backup.cpp
@@ -266,6 +266,65 @@ Backup::execCONTINUEB(Signal* signal)
   const Uint32 Tdata2 = signal->theData[2];
   
   switch(Tdata0) {
+  case BackupContinueB::BACKUP_FRAGMENT_INFO:
+  {
+    const Uint32 ptr_I = Tdata1;
+    Uint32 tabPtr_I = Tdata2;
+    Uint32 fragPtr_I = signal->theData[3];
+
+    BackupRecordPtr ptr;
+    c_backupPool.getPtr(ptr, ptr_I);
+    TablePtr tabPtr;
+    ptr.p->tables.getPtr(tabPtr, tabPtr_I);
+    FragmentPtr fragPtr;
+    tabPtr.p->fragments.getPtr(fragPtr, fragPtr_I);
+
+    BackupFilePtr filePtr;
+    ptr.p->files.getPtr(filePtr, ptr.p->ctlFilePtr);
+
+    const Uint32 sz = sizeof(BackupFormat::CtlFile::FragmentInfo) >> 2;
+    Uint32 * dst;
+    if (!filePtr.p->operation.dataBuffer.getWritePtr(&dst, sz))
+    {
+      sendSignalWithDelay(BACKUP_REF, GSN_CONTINUEB, signal, 100, 4);
+      return;
+    }
+
+    BackupFormat::CtlFile::FragmentInfo * fragInfo = 
+      (BackupFormat::CtlFile::FragmentInfo*)dst;
+    fragInfo->SectionType = htonl(BackupFormat::FRAGMENT_INFO);
+    fragInfo->SectionLength = htonl(sz);
+    fragInfo->TableId = htonl(fragPtr.p->tableId);
+    fragInfo->FragmentNo = htonl(fragPtr_I);
+    fragInfo->NoOfRecordsLow = htonl(fragPtr.p->noOfRecords & 0xFFFFFFFF);
+    fragInfo->NoOfRecordsHigh = htonl(fragPtr.p->noOfRecords >> 32);
+    fragInfo->FilePosLow = htonl(0 & 0xFFFFFFFF);
+    fragInfo->FilePosHigh = htonl(0 >> 32);
+
+    filePtr.p->operation.dataBuffer.updateWritePtr(sz);
+
+    fragPtr_I++;
+    if (fragPtr_I == tabPtr.p->fragments.getSize())
+    {
+      signal->theData[0] = tabPtr.p->tableId;
+      signal->theData[1] = 0; // unlock
+      EXECUTE_DIRECT(DBDICT, GSN_BACKUP_FRAGMENT_REQ, signal, 2);
+
+      fragPtr_I = 0;
+      ptr.p->tables.next(tabPtr);
+      if ((tabPtr_I = tabPtr.i) == RNIL)
+      {
+        closeFiles(signal, ptr);
+        return;
+      }
+    }
+    signal->theData[0] = BackupContinueB::BACKUP_FRAGMENT_INFO;
+    signal->theData[1] = ptr_I;
+    signal->theData[2] = tabPtr_I;
+    signal->theData[3] = fragPtr_I;
+    sendSignal(BACKUP_REF, GSN_CONTINUEB, signal, 4, JBB);
+    return;
+  }
   case BackupContinueB::START_FILE_THREAD:
   case BackupContinueB::BUFFER_UNDERFLOW:
   {
@@ -455,7 +514,7 @@ Backup::findTable(const BackupRecordPtr & ptr,
   return false;
 }
 
-static Uint32 xps(Uint32 x, Uint64 ms)
+static Uint32 xps(Uint64 x, Uint64 ms)
 {
   float fx = x;
   float fs = ms;
@@ -469,9 +528,9 @@ static Uint32 xps(Uint32 x, Uint64 ms)
 }
 
 struct Number {
-  Number(Uint32 r) { val = r;}
-  Number & operator=(Uint32 r) { val = r; return * this; }
-  Uint32 val;
+  Number(Uint64 r) { val = r;}
+  Number & operator=(Uint64 r) { val = r; return * this; }
+  Uint64 val;
 };
 
 NdbOut &
@@ -545,8 +604,10 @@ Backup::execBACKUP_COMPLETE_REP(Signal* signal)
   startTime = NdbTick_CurrentMillisecond() - startTime;
   
   ndbout_c("Backup %d has completed", rep->backupId);
-  const Uint32 bytes = rep->noOfBytes;
-  const Uint32 records = rep->noOfRecords;
+  const Uint64 bytes =
+    rep->noOfBytesLow + (((Uint64)rep->noOfBytesHigh) << 32);
+  const Uint64 records =
+    rep->noOfRecordsLow + (((Uint64)rep->noOfRecordsHigh) << 32);
 
   Number rps = xps(records, startTime);
   Number bps = xps(bytes, startTime);
@@ -1905,8 +1966,10 @@ Backup::execBACKUP_FRAGMENT_CONF(Signal* signal)
   const Uint32 tableId = conf->tableId;
   const Uint32 fragmentNo = conf->fragmentNo;
   const Uint32 nodeId = refToNode(signal->senderBlockRef());
-  const Uint32 noOfBytes = conf->noOfBytes;
-  const Uint32 noOfRecords = conf->noOfRecords;
+  const Uint64 noOfBytes =
+    conf->noOfBytesLow + (((Uint64)conf->noOfBytesHigh) << 32);
+  const Uint64 noOfRecords =
+    conf->noOfRecordsLow + (((Uint64)conf->noOfRecordsHigh) << 32);
 
   BackupRecordPtr ptr;
   c_backupPool.getPtr(ptr, ptrI);
@@ -1918,9 +1981,13 @@ Backup::execBACKUP_FRAGMENT_CONF(Signal* signal)
   TablePtr tabPtr;
   ndbrequire(findTable(ptr, tabPtr, tableId));
 
+  tabPtr.p->noOfRecords += noOfRecords;
+
   FragmentPtr fragPtr;
   tabPtr.p->fragments.getPtr(fragPtr, fragmentNo);
 
+  fragPtr.p->noOfRecords = noOfRecords;
+
   ndbrequire(fragPtr.p->scanned == 0);
   ndbrequire(fragPtr.p->scanning == 1);
   ndbrequire(fragPtr.p->node == nodeId);
@@ -1944,6 +2011,24 @@ Backup::execBACKUP_FRAGMENT_CONF(Signal* signal)
   }
   else
   {
+    NodeBitmask nodes = ptr.p->nodes;
+    nodes.clear(getOwnNodeId());
+    if (!nodes.isclear())
+    {
+      BackupFragmentCompleteRep *rep =
+        (BackupFragmentCompleteRep*)signal->getDataPtrSend();
+      rep->backupId = ptr.p->backupId;
+      rep->backupPtr = ptr.i;
+      rep->tableId = tableId;
+      rep->fragmentNo = fragmentNo;
+      rep->noOfTableRowsLow = (Uint32)(tabPtr.p->noOfRecords & 0xFFFFFFFF);
+      rep->noOfTableRowsHigh = (Uint32)(tabPtr.p->noOfRecords >> 32);
+      rep->noOfFragmentRowsLow = (Uint32)(noOfRecords & 0xFFFFFFFF);
+      rep->noOfFragmentRowsHigh = (Uint32)(noOfRecords >> 32);
+      NodeReceiverGroup rg(BACKUP, ptr.p->nodes);
+      sendSignal(rg, GSN_BACKUP_FRAGMENT_COMPLETE_REP, signal,
+                 BackupFragmentCompleteRep::SignalLength, JBB);
+    }
     nextFragment(signal, ptr);
   }
 }
@@ -2006,6 +2091,29 @@ err:
   execABORT_BACKUP_ORD(signal);
 }
 
+void
+Backup::execBACKUP_FRAGMENT_COMPLETE_REP(Signal* signal)
+{
+  jamEntry();
+  BackupFragmentCompleteRep * rep =
+    (BackupFragmentCompleteRep*)signal->getDataPtr();
+
+  BackupRecordPtr ptr;
+  c_backupPool.getPtr(ptr, rep->backupPtr);
+
+  TablePtr tabPtr;
+  ndbrequire(findTable(ptr, tabPtr, rep->tableId));
+
+  tabPtr.p->noOfRecords =
+    rep->noOfTableRowsLow + (((Uint64)rep->noOfTableRowsHigh) << 32);
+
+  FragmentPtr fragPtr;
+  tabPtr.p->fragments.getPtr(fragPtr, rep->fragmentNo);
+
+  fragPtr.p->noOfRecords =
+    rep->noOfFragmentRowsLow + (((Uint64)rep->noOfFragmentRowsHigh) << 32);
+}
+
 /*****************************************************************************
  * 
  * Master functionallity - Drop triggers
@@ -2206,8 +2314,10 @@ Backup::stopBackupReply(Signal* signal, BackupRecordPtr ptr, Uint32 nodeId)
       rep->senderData = ptr.p->clientData;
       rep->startGCP = ptr.p->startGCP;
       rep->stopGCP = ptr.p->stopGCP;
-      rep->noOfBytes = ptr.p->noOfBytes;
-      rep->noOfRecords = ptr.p->noOfRecords;
+      rep->noOfBytesLow = (Uint32)(ptr.p->noOfBytes & 0xFFFFFFFF);
+      rep->noOfRecordsLow = (Uint32)(ptr.p->noOfRecords & 0xFFFFFFFF);
+      rep->noOfBytesHigh = (Uint32)(ptr.p->noOfBytes >> 32);
+      rep->noOfRecordsHigh = (Uint32)(ptr.p->noOfRecords >> 32);
       rep->noOfLogBytes = ptr.p->noOfLogBytes;
       rep->noOfLogRecords = ptr.p->noOfLogRecords;
       rep->nodes = ptr.p->nodes;
@@ -2220,12 +2330,14 @@ Backup::stopBackupReply(Signal* signal, BackupRecordPtr ptr, Uint32 nodeId)
     signal->theData[2] = ptr.p->backupId;
     signal->theData[3] = ptr.p->startGCP;
     signal->theData[4] = ptr.p->stopGCP;
-    signal->theData[5] = ptr.p->noOfBytes;
-    signal->theData[6] = ptr.p->noOfRecords;
+    signal->theData[5] = (Uint32)(ptr.p->noOfBytes & 0xFFFFFFFF);
+    signal->theData[6] = (Uint32)(ptr.p->noOfRecords & 0xFFFFFFFF);
     signal->theData[7] = ptr.p->noOfLogBytes;
     signal->theData[8] = ptr.p->noOfLogRecords;
     ptr.p->nodes.copyto(NdbNodeBitmask::Size, signal->theData+9);
-    sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 9+NdbNodeBitmask::Size, JBB);
+    signal->theData[9+NdbNodeBitmask::Size] = (Uint32)(ptr.p->noOfBytes >> 32);
+    signal->theData[10+NdbNodeBitmask::Size] = (Uint32)(ptr.p->noOfRecords >> 32);
+    sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 11+NdbNodeBitmask::Size, JBB);
   }
   else
   {
@@ -2988,6 +3100,7 @@ Backup::parseTableDescription(Signal* signal, BackupRecordPtr ptr, Uint32 len)
   /**
    * Initialize table object
    */
+  tabPtr.p->noOfRecords = 0;
   tabPtr.p->schemaVersion = tmpTab.TableVersion;
   tabPtr.p->noOfAttributes = tmpTab.NoOfAttributes;
   tabPtr.p->noOfNull = 0;
@@ -3695,8 +3808,10 @@ Backup::fragmentCompleted(Signal* signal, BackupFilePtr filePtr)
   conf->backupPtr = ptr.i;
   conf->tableId = filePtr.p->tableId;
   conf->fragmentNo = filePtr.p->fragmentNo;
-  conf->noOfRecords = op.noOfRecords;
-  conf->noOfBytes = op.noOfBytes;
+  conf->noOfRecordsLow = (Uint32)(op.noOfRecords & 0xFFFFFFFF);
+  conf->noOfRecordsHigh = (Uint32)(op.noOfRecords >> 32);
+  conf->noOfBytesLow = (Uint32)(op.noOfBytes & 0xFFFFFFFF);
+  conf->noOfBytesHigh = (Uint32)(op.noOfBytes >> 32);
   sendSignal(ptr.p->masterRef, GSN_BACKUP_FRAGMENT_CONF, signal,
 	     BackupFragmentConf::SignalLength, JBB);
   
@@ -4123,20 +4238,18 @@ Backup::execSTOP_BACKUP_REQ(Signal* signal)
     gcp->StartGCP      = htonl(startGCP);
     gcp->StopGCP       = htonl(stopGCP - 1);
     filePtr.p->operation.dataBuffer.updateWritePtr(gcpSz);
-  }
 
-  {
-    TablePtr tabPtr;
-    for(ptr.p->tables.first(tabPtr); tabPtr.i != RNIL;
-	ptr.p->tables.next(tabPtr))
     {
-      signal->theData[0] = tabPtr.p->tableId;
-      signal->theData[1] = 0; // unlock
-      EXECUTE_DIRECT(DBDICT, GSN_BACKUP_FRAGMENT_REQ, signal, 2);
+      TablePtr tabPtr;
+      ptr.p->tables.first(tabPtr);
+
+      signal->theData[0] = BackupContinueB::BACKUP_FRAGMENT_INFO;
+      signal->theData[1] = ptr.i;
+      signal->theData[2] = tabPtr.i;
+      signal->theData[3] = 0;
+      sendSignal(BACKUP_REF, GSN_CONTINUEB, signal, 4, JBB);
     }
   }
-  
-  closeFiles(signal, ptr);
 }
 
 void
diff --git a/ndb/src/kernel/blocks/backup/Backup.hpp b/ndb/src/kernel/blocks/backup/Backup.hpp
index c455e32fa67..e37923da749 100644
--- a/ndb/src/kernel/blocks/backup/Backup.hpp
+++ b/ndb/src/kernel/blocks/backup/Backup.hpp
@@ -68,6 +68,7 @@ protected:
   void execBACKUP_DATA(Signal* signal);
   void execSTART_BACKUP_REQ(Signal* signal);
   void execBACKUP_FRAGMENT_REQ(Signal* signal);
+  void execBACKUP_FRAGMENT_COMPLETE_REP(Signal* signal);
   void execSTOP_BACKUP_REQ(Signal* signal);
   void execBACKUP_STATUS_REQ(Signal* signal);
   void execABORT_BACKUP_ORD(Signal* signal);
@@ -183,10 +184,12 @@ public:
   typedef Ptr<Attribute> AttributePtr;
   
   struct Fragment {
+    Uint64 noOfRecords;
     Uint32 tableId;
-    Uint32 node;
-    Uint16 scanned;  // 0 = not scanned x = scanned by node x
-    Uint16 scanning; // 0 = not scanning x = scanning on node x
+    Uint8  node;
+    Uint8  scanned;  // 0 = not scanned x = scanned by node x
+    Uint8  scanning; // 0 = not scanning x = scanning on node x
+    Uint8  unused1;
     Uint32 nextPool;
   };
   typedef Ptr<Fragment> FragmentPtr;
@@ -194,6 +197,8 @@ public:
   struct Table {
     Table(ArrayPool<Attribute> &, ArrayPool<Fragment> &);
     
+    Uint64 noOfRecords;
+
     Uint32 tableId;
     Uint32 schemaVersion;
     Uint32 tableType;
@@ -269,8 +274,8 @@ public:
     Uint32 tablePtr;    // Ptr.i to current table
 
     FsBuffer dataBuffer;
-    Uint32 noOfRecords;
-    Uint32 noOfBytes;
+    Uint64 noOfRecords;
+    Uint64 noOfBytes;
     Uint32 maxRecordSize;
     
   private:
diff --git a/ndb/src/kernel/blocks/backup/BackupFormat.hpp b/ndb/src/kernel/blocks/backup/BackupFormat.hpp
index 65dd2ad9053..b8ffff3a294 100644
--- a/ndb/src/kernel/blocks/backup/BackupFormat.hpp
+++ b/ndb/src/kernel/blocks/backup/BackupFormat.hpp
@@ -32,7 +32,8 @@ struct BackupFormat {
     FRAGMENT_FOOTER   = 3,
     TABLE_LIST        = 4,
     TABLE_DESCRIPTION = 5,
-    GCP_ENTRY         = 6
+    GCP_ENTRY         = 6,
+    FRAGMENT_INFO     = 7
   };
 
   struct FileHeader {
@@ -126,6 +127,20 @@ struct BackupFormat {
       Uint32 StartGCP;
       Uint32 StopGCP;
     };
+
+    /**
+     * Fragment Info
+     */
+    struct FragmentInfo {
+      Uint32 SectionType;
+      Uint32 SectionLength;
+      Uint32 TableId;
+      Uint32 FragmentNo;
+      Uint32 NoOfRecordsLow;
+      Uint32 NoOfRecordsHigh;
+      Uint32 FilePosLow;
+      Uint32 FilePosHigh;
+    };
   };
 
   /**
diff --git a/ndb/src/kernel/blocks/backup/BackupInit.cpp b/ndb/src/kernel/blocks/backup/BackupInit.cpp
index 4c734d58c8e..96c11468939 100644
--- a/ndb/src/kernel/blocks/backup/BackupInit.cpp
+++ b/ndb/src/kernel/blocks/backup/BackupInit.cpp
@@ -97,6 +97,9 @@ Backup::Backup(const Configuration & conf) :
   addRecSignal(GSN_BACKUP_FRAGMENT_REQ, &Backup::execBACKUP_FRAGMENT_REQ);
   addRecSignal(GSN_BACKUP_FRAGMENT_REF, &Backup::execBACKUP_FRAGMENT_REF);
   addRecSignal(GSN_BACKUP_FRAGMENT_CONF, &Backup::execBACKUP_FRAGMENT_CONF);
+
+  addRecSignal(GSN_BACKUP_FRAGMENT_COMPLETE_REP,
+               &Backup::execBACKUP_FRAGMENT_COMPLETE_REP);
   
   addRecSignal(GSN_STOP_BACKUP_REQ, &Backup::execSTOP_BACKUP_REQ);
   addRecSignal(GSN_STOP_BACKUP_REF, &Backup::execSTOP_BACKUP_REF);
diff --git a/ndb/src/kernel/blocks/dbdict/Dbdict.cpp b/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
index 3cdba251492..133b4d75d8e 100644
--- a/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
+++ b/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
@@ -286,6 +286,10 @@ Dbdict::packTableIntoPagesImpl(SimpleProperties::Writer & w,
   w.add(DictTabInfo::TableKValue, tablePtr.p->kValue);
   w.add(DictTabInfo::FragmentTypeVal, tablePtr.p->fragmentType);
   w.add(DictTabInfo::TableTypeVal, tablePtr.p->tableType);
+  w.add(DictTabInfo::MaxRowsLow, tablePtr.p->maxRowsLow);
+  w.add(DictTabInfo::MaxRowsHigh, tablePtr.p->maxRowsHigh);
+  w.add(DictTabInfo::MinRowsLow, tablePtr.p->minRowsLow);
+  w.add(DictTabInfo::MinRowsHigh, tablePtr.p->minRowsHigh);
   
   if(!signal)
   {
@@ -1535,6 +1539,10 @@ void Dbdict::initialiseTableRecord(TableRecordPtr tablePtr)
   tablePtr.p->minLoadFactor = 70;
   tablePtr.p->noOfPrimkey = 1;
   tablePtr.p->tupKeyLength = 1;
+  tablePtr.p->maxRowsLow = 0;
+  tablePtr.p->maxRowsHigh = 0;
+  tablePtr.p->minRowsLow = 0;
+  tablePtr.p->minRowsHigh = 0;
   tablePtr.p->storedTable = true;
   tablePtr.p->tableType = DictTabInfo::UserTable;
   tablePtr.p->primaryTableId = RNIL;
@@ -4501,6 +4509,13 @@ Dbdict::execADD_FRAGREQ(Signal* signal) {
   Uint32 lhPageBits = 0;
   ::calcLHbits(&lhPageBits, &lhDistrBits, fragId, fragCount);
 
+  Uint64 maxRows = tabPtr.p->maxRowsLow +
+    (((Uint64)tabPtr.p->maxRowsHigh) << 32);
+  Uint64 minRows = tabPtr.p->minRowsLow +
+    (((Uint64)tabPtr.p->minRowsHigh) << 32);
+  maxRows = (maxRows + fragCount - 1) / fragCount;
+  minRows = (minRows + fragCount - 1) / fragCount;
+
   {  
     LqhFragReq* req = (LqhFragReq*)signal->getDataPtrSend();
     req->senderData = senderData;
@@ -4516,7 +4531,10 @@ Dbdict::execADD_FRAGREQ(Signal* signal) {
     req->lh3PageBits = 0; //lhPageBits;
     req->noOfAttributes = tabPtr.p->noOfAttributes;
     req->noOfNullAttributes = tabPtr.p->noOfNullBits;
-    req->noOfPagesToPreAllocate = 0;
+    req->maxRowsLow = maxRows & 0xFFFFFFFF;
+    req->maxRowsHigh = maxRows >> 32;
+    req->minRowsLow = minRows & 0xFFFFFFFF;
+    req->minRowsHigh = minRows >> 32;
     req->schemaVersion = tabPtr.p->tableVersion;
     Uint32 keyLen = tabPtr.p->tupKeyLength;
     req->keyLength = keyLen; // wl-2066 no more "long keys"
@@ -4524,8 +4542,7 @@ Dbdict::execADD_FRAGREQ(Signal* signal) {
 
     req->noOfKeyAttr = tabPtr.p->noOfPrimkey;
     req->noOfNewAttr = 0;
-    // noOfCharsets passed to TUP in upper half
-    req->noOfNewAttr |= (tabPtr.p->noOfCharsets << 16);
+    req->noOfCharsets = tabPtr.p->noOfCharsets;
     req->checksumIndicator = 1;
     req->noOfAttributeGroups = 1;
     req->GCPIndicator = 0;
@@ -5091,6 +5108,15 @@ void Dbdict::handleTabInfoInit(SimpleProperties::Reader & it,
   tablePtr.p->tableType = (DictTabInfo::TableType)tableDesc.TableType;
   tablePtr.p->kValue = tableDesc.TableKValue;
   tablePtr.p->fragmentCount = tableDesc.FragmentCount;
+  tablePtr.p->maxRowsLow = tableDesc.MaxRowsLow;
+  tablePtr.p->maxRowsHigh = tableDesc.MaxRowsHigh;
+  tablePtr.p->minRowsLow = tableDesc.MinRowsLow;
+  tablePtr.p->minRowsHigh = tableDesc.MinRowsHigh;
+
+  Uint64 maxRows =
+    (((Uint64)tablePtr.p->maxRowsHigh) << 32) + tablePtr.p->maxRowsLow;
+  Uint64 minRows =
+    (((Uint64)tablePtr.p->minRowsHigh) << 32) + tablePtr.p->minRowsLow;
 
   tablePtr.p->frmLen = tableDesc.FrmLen;
   memcpy(tablePtr.p->frmData, tableDesc.FrmData, tableDesc.FrmLen);  
diff --git a/ndb/src/kernel/blocks/dbdict/Dbdict.hpp b/ndb/src/kernel/blocks/dbdict/Dbdict.hpp
index 9c0bf65b69c..91e57720d01 100644
--- a/ndb/src/kernel/blocks/dbdict/Dbdict.hpp
+++ b/ndb/src/kernel/blocks/dbdict/Dbdict.hpp
@@ -134,6 +134,10 @@ public:
    * on disk.  Index trigger ids are volatile.
    */
   struct TableRecord : public MetaData::Table {
+    Uint32 maxRowsLow;
+    Uint32 maxRowsHigh;
+    Uint32 minRowsLow;
+    Uint32 minRowsHigh;
     /****************************************************
      *    Support variables for table handling
      ****************************************************/
diff --git a/ndb/src/kernel/blocks/dblqh/Dblqh.hpp b/ndb/src/kernel/blocks/dblqh/Dblqh.hpp
index 1ed383853ba..f8e6292f7f2 100644
--- a/ndb/src/kernel/blocks/dblqh/Dblqh.hpp
+++ b/ndb/src/kernel/blocks/dblqh/Dblqh.hpp
@@ -443,7 +443,6 @@ public:
     UintR dictConnectptr;
     UintR fragmentPtr;
     UintR nextAddfragrec;
-    UintR noOfAllocPages;
     UintR schemaVer;
     UintR tup1Connectptr;
     UintR tup2Connectptr;
@@ -465,12 +464,17 @@ public:
     Uint16 totalAttrReceived;
     Uint16 fragCopyCreation;
     Uint16 noOfKeyAttr;
-    Uint32 noOfNewAttr; // noOfCharsets in upper half
+    Uint16 noOfNewAttr;
+    Uint16 noOfCharsets;
     Uint16 noOfAttributeGroups;
     Uint16 lh3DistrBits;
     Uint16 tableType;
     Uint16 primaryTableId;
-  };// Size 108 bytes
+    Uint32 maxRowsLow;
+    Uint32 maxRowsHigh;
+    Uint32 minRowsLow;
+    Uint32 minRowsHigh;
+  };// Size 124 bytes
   typedef Ptr<AddFragRecord> AddFragRecordPtr;
   
   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
diff --git a/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp b/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
index 56e93e6ee01..ecb67d04050 100644
--- a/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
+++ b/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
@@ -939,12 +939,16 @@ void Dblqh::execLQHFRAGREQ(Signal* signal)
   Uint8 tlh = req->lh3PageBits;
   Uint32 tnoOfAttr = req->noOfAttributes;
   Uint32 tnoOfNull = req->noOfNullAttributes;
-  Uint32 noOfAlloc = req->noOfPagesToPreAllocate;
+  Uint32 maxRowsLow = req->maxRowsLow;
+  Uint32 maxRowsHigh = req->maxRowsHigh;
+  Uint32 minRowsLow = req->minRowsLow;
+  Uint32 minRowsHigh = req->minRowsHigh;
   Uint32 tschemaVersion = req->schemaVersion;
   Uint32 ttupKeyLength = req->keyLength;
   Uint32 nextLcp = req->nextLCP;
   Uint32 noOfKeyAttr = req->noOfKeyAttr;
   Uint32 noOfNewAttr = req->noOfNewAttr;
+  Uint32 noOfCharsets = req->noOfCharsets;
   Uint32 checksumIndicator = req->checksumIndicator;
   Uint32 noOfAttributeGroups = req->noOfAttributeGroups;
   Uint32 gcpIndicator = req->GCPIndicator;
@@ -1042,7 +1046,10 @@ void Dblqh::execLQHFRAGREQ(Signal* signal)
   addfragptr.p->m_senderAttrPtr = RNIL;
   addfragptr.p->noOfAttr = tnoOfAttr;
   addfragptr.p->noOfNull = tnoOfNull;
-  addfragptr.p->noOfAllocPages = noOfAlloc;
+  addfragptr.p->maxRowsLow = maxRowsLow;
+  addfragptr.p->maxRowsHigh = maxRowsHigh;
+  addfragptr.p->minRowsLow = minRowsLow;
+  addfragptr.p->minRowsHigh = minRowsHigh;
   addfragptr.p->tabId = tabptr.i;
   addfragptr.p->totalAttrReceived = 0;
   addfragptr.p->attrSentToTup = ZNIL;/* TO FIND PROGRAMMING ERRORS QUICKLY */
@@ -1052,6 +1059,7 @@ void Dblqh::execLQHFRAGREQ(Signal* signal)
   addfragptr.p->addfragErrorCode = 0;
   addfragptr.p->noOfKeyAttr = noOfKeyAttr;
   addfragptr.p->noOfNewAttr = noOfNewAttr;
+  addfragptr.p->noOfCharsets = noOfCharsets;
   addfragptr.p->checksumIndicator = checksumIndicator;
   addfragptr.p->noOfAttributeGroups = noOfAttributeGroups;
   addfragptr.p->GCPIndicator = gcpIndicator;
@@ -1221,47 +1229,56 @@ Dblqh::sendAddFragReq(Signal* signal)
   ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord);
   if (addfragptr.p->addfragStatus == AddFragRecord::WAIT_TWO_TUP ||
       addfragptr.p->addfragStatus == AddFragRecord::WAIT_ONE_TUP) {
+    TupFragReq* const tupFragReq = (TupFragReq*)signal->getDataPtrSend();
     if (DictTabInfo::isTable(addfragptr.p->tableType) ||
         DictTabInfo::isHashIndex(addfragptr.p->tableType)) {
       jam();
-      signal->theData[0] = addfragptr.i;
-      signal->theData[1] = cownref;
-      signal->theData[2] = 0; /* ADD TABLE */
-      signal->theData[3] = addfragptr.p->tabId;
-      signal->theData[4] = addfragptr.p->noOfAttr;
-      signal->theData[5] =
+      tupFragReq->userPtr = addfragptr.i;
+      tupFragReq->userRef = cownref;
+      tupFragReq->reqInfo = 0; /* ADD TABLE */
+      tupFragReq->tableId = addfragptr.p->tabId;
+      tupFragReq->noOfAttr = addfragptr.p->noOfAttr;
+      tupFragReq->fragId =
         addfragptr.p->addfragStatus == AddFragRecord::WAIT_TWO_TUP
         ? addfragptr.p->fragid1 : addfragptr.p->fragid2;
-      signal->theData[6] = (addfragptr.p->noOfAllocPages >> 1) + 1;
-      signal->theData[7] = addfragptr.p->noOfNull;
-      signal->theData[8] = addfragptr.p->schemaVer;
-      signal->theData[9] = addfragptr.p->noOfKeyAttr;
-      signal->theData[10] = addfragptr.p->noOfNewAttr;
-      signal->theData[11] = addfragptr.p->checksumIndicator;
-      signal->theData[12] = addfragptr.p->noOfAttributeGroups;
-      signal->theData[13] = addfragptr.p->GCPIndicator;
+      tupFragReq->maxRowsLow = addfragptr.p->maxRowsLow;
+      tupFragReq->maxRowsHigh = addfragptr.p->maxRowsHigh;
+      tupFragReq->minRowsLow = addfragptr.p->minRowsLow;
+      tupFragReq->minRowsHigh = addfragptr.p->minRowsHigh;
+      tupFragReq->noOfNullAttr = addfragptr.p->noOfNull;
+      tupFragReq->schemaVersion = addfragptr.p->schemaVer;
+      tupFragReq->noOfKeyAttr = addfragptr.p->noOfKeyAttr;
+      tupFragReq->noOfNewAttr = addfragptr.p->noOfNewAttr;
+      tupFragReq->noOfCharsets = addfragptr.p->noOfCharsets;
+      tupFragReq->checksumIndicator = addfragptr.p->checksumIndicator;
+      tupFragReq->noOfAttributeGroups = addfragptr.p->noOfAttributeGroups;
+      tupFragReq->globalCheckpointIdIndicator = addfragptr.p->GCPIndicator;
       sendSignal(fragptr.p->tupBlockref, GSN_TUPFRAGREQ,
           signal, TupFragReq::SignalLength, JBB);
       return;
     }
     if (DictTabInfo::isOrderedIndex(addfragptr.p->tableType)) {
       jam();
-      signal->theData[0] = addfragptr.i;
-      signal->theData[1] = cownref;
-      signal->theData[2] = 0; /* ADD TABLE */
-      signal->theData[3] = addfragptr.p->tabId;
-      signal->theData[4] = 1; /* ordered index: one array attr */
-      signal->theData[5] =
+      tupFragReq->userPtr = addfragptr.i;
+      tupFragReq->userRef = cownref;
+      tupFragReq->reqInfo = 0; /* ADD TABLE */
+      tupFragReq->tableId = addfragptr.p->tabId;
+      tupFragReq->noOfAttr = 1; /* ordered index: one array attr */
+      tupFragReq->fragId =
         addfragptr.p->addfragStatus == AddFragRecord::WAIT_TWO_TUP
         ? addfragptr.p->fragid1 : addfragptr.p->fragid2;
-      signal->theData[6] = (addfragptr.p->noOfAllocPages >> 1) + 1;
-      signal->theData[7] = 0; /* ordered index: no nullable */
-      signal->theData[8] = addfragptr.p->schemaVer;
-      signal->theData[9] = 1; /* ordered index: one key */
-      signal->theData[10] = addfragptr.p->noOfNewAttr;
-      signal->theData[11] = addfragptr.p->checksumIndicator;
-      signal->theData[12] = addfragptr.p->noOfAttributeGroups;
-      signal->theData[13] = addfragptr.p->GCPIndicator;
+      tupFragReq->maxRowsLow = addfragptr.p->maxRowsLow;
+      tupFragReq->maxRowsHigh = addfragptr.p->maxRowsHigh;
+      tupFragReq->minRowsLow = addfragptr.p->minRowsLow;
+      tupFragReq->minRowsHigh = addfragptr.p->minRowsHigh;
+      tupFragReq->noOfNullAttr = 0; /* ordered index: no nullable */
+      tupFragReq->schemaVersion = addfragptr.p->schemaVer;
+      tupFragReq->noOfKeyAttr = 1; /* ordered index: one key */
+      tupFragReq->noOfNewAttr = addfragptr.p->noOfNewAttr;
+      tupFragReq->noOfCharsets = addfragptr.p->noOfCharsets;
+      tupFragReq->checksumIndicator = addfragptr.p->checksumIndicator;
+      tupFragReq->noOfAttributeGroups = addfragptr.p->noOfAttributeGroups;
+      tupFragReq->globalCheckpointIdIndicator = addfragptr.p->GCPIndicator;
       sendSignal(fragptr.p->tupBlockref, GSN_TUPFRAGREQ,
           signal, TupFragReq::SignalLength, JBB);
       return;
@@ -1580,28 +1597,35 @@ void Dblqh::abortAddFragOps(Signal* signal)
 {
   fragptr.i = addfragptr.p->fragmentPtr;
   ptrCheckGuard(fragptr, cfragrecFileSize, fragrecord);
-  signal->theData[0] = (Uint32)-1;
   if (addfragptr.p->tup1Connectptr != RNIL) {
     jam();
-    signal->theData[1] = addfragptr.p->tup1Connectptr;
+    TupFragReq* const tupFragReq = (TupFragReq*)signal->getDataPtrSend();
+    tupFragReq->userPtr = (Uint32)-1;
+    tupFragReq->userRef = addfragptr.p->tup1Connectptr;
     sendSignal(fragptr.p->tupBlockref, GSN_TUPFRAGREQ, signal, 2, JBB);
     addfragptr.p->tup1Connectptr = RNIL;
   }
   if (addfragptr.p->tup2Connectptr != RNIL) {
     jam();
-    signal->theData[1] = addfragptr.p->tup2Connectptr;
+    TupFragReq* const tupFragReq = (TupFragReq*)signal->getDataPtrSend();
+    tupFragReq->userPtr = (Uint32)-1;
+    tupFragReq->userRef = addfragptr.p->tup2Connectptr;
     sendSignal(fragptr.p->tupBlockref, GSN_TUPFRAGREQ, signal, 2, JBB);
     addfragptr.p->tup2Connectptr = RNIL;
   }
   if (addfragptr.p->tux1Connectptr != RNIL) {
     jam();
-    signal->theData[1] = addfragptr.p->tux1Connectptr;
+    TuxFragReq* const tuxFragReq = (TuxFragReq*)signal->getDataPtrSend();
+    tuxFragReq->userPtr = (Uint32)-1;
+    tuxFragReq->userRef = addfragptr.p->tux1Connectptr;
     sendSignal(fragptr.p->tuxBlockref, GSN_TUXFRAGREQ, signal, 2, JBB);
     addfragptr.p->tux1Connectptr = RNIL;
   }
   if (addfragptr.p->tux2Connectptr != RNIL) {
     jam();
-    signal->theData[1] = addfragptr.p->tux2Connectptr;
+    TuxFragReq* const tuxFragReq = (TuxFragReq*)signal->getDataPtrSend();
+    tuxFragReq->userPtr = (Uint32)-1;
+    tuxFragReq->userRef = addfragptr.p->tux2Connectptr;
     sendSignal(fragptr.p->tuxBlockref, GSN_TUXFRAGREQ, signal, 2, JBB);
     addfragptr.p->tux2Connectptr = RNIL;
   }
diff --git a/ndb/src/kernel/blocks/dbtup/Dbtup.hpp b/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
index cf3c6056d65..41194fba82c 100644
--- a/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
+++ b/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
@@ -496,7 +496,8 @@ struct DiskBufferSegmentInfo {
 typedef Ptr<DiskBufferSegmentInfo> DiskBufferSegmentInfoPtr;
 
 struct Fragoperrec {
-  bool   definingFragment;
+  Uint64 minRows;
+  Uint64 maxRows;
   Uint32 nextFragoprec;
   Uint32 lqhPtrFrag;
   Uint32 fragidFrag;
@@ -509,6 +510,7 @@ struct Fragoperrec {
   Uint32 charsetIndex;
   BlockReference lqhBlockrefFrag;
   bool inUse;
+  bool definingFragment;
 };
 typedef Ptr<Fragoperrec> FragoperrecPtr;
 
@@ -560,6 +562,7 @@ struct Fragrecord {
   Uint32 currentPageRange;
   Uint32 rootPageRange;
   Uint32 noOfPages;
+  Uint32 noOfPagesToGrow;
   Uint32 emptyPrimPage;
 
   Uint32 firstusedOprec;
diff --git a/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp b/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp
index bacba2a880c..12cd61a17a6 100644
--- a/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp
+++ b/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp
@@ -41,7 +41,8 @@ void Dbtup::execTUPFRAGREQ(Signal* signal)
 {
   ljamEntry();
 
-  if (signal->theData[0] == (Uint32)-1) {
+  TupFragReq* tupFragReq = (TupFragReq*)signal->getDataPtr();
+  if (tupFragReq->userPtr == (Uint32)-1) {
     ljam();
     abortAddFragOp(signal);
     return;
@@ -51,30 +52,34 @@ void Dbtup::execTUPFRAGREQ(Signal* signal)
   FragrecordPtr regFragPtr;
   TablerecPtr regTabPtr;
 
-  Uint32 userptr = signal->theData[0];
-  Uint32 userblockref = signal->theData[1];
-  Uint32 reqinfo = signal->theData[2];
-  regTabPtr.i = signal->theData[3];
-  Uint32 noOfAttributes = signal->theData[4];
-  Uint32 fragId = signal->theData[5];
-  Uint32 noOfNullAttr = signal->theData[7];
-  /*  Uint32 schemaVersion = signal->theData[8];*/
-  Uint32 noOfKeyAttr = signal->theData[9];
+  Uint32 userptr        = tupFragReq->userPtr;
+  Uint32 userblockref   = tupFragReq->userRef;
+  Uint32 reqinfo        = tupFragReq->reqInfo;
+  regTabPtr.i           = tupFragReq->tableId;
+  Uint32 noOfAttributes = tupFragReq->noOfAttr;
+  Uint32 fragId         = tupFragReq->fragId;
+  Uint32 noOfNullAttr = tupFragReq->noOfNullAttr;
+  /*  Uint32 schemaVersion = tupFragReq->schemaVersion;*/
+  Uint32 noOfKeyAttr = tupFragReq->noOfKeyAttr;
 
-  Uint32 noOfNewAttr = (signal->theData[10] & 0xFFFF);
-  /* DICT sends number of character sets in upper half */
-  Uint32 noOfCharsets = (signal->theData[10] >> 16);
+  Uint32 noOfNewAttr = tupFragReq->noOfNewAttr;
+  Uint32 noOfCharsets = tupFragReq->noOfCharsets;
 
-  Uint32 checksumIndicator = signal->theData[11];
-  Uint32 noOfAttributeGroups = signal->theData[12];
-  Uint32 globalCheckpointIdIndicator = signal->theData[13];
+  Uint32 checksumIndicator = tupFragReq->checksumIndicator;
+  Uint32 noOfAttributeGroups = tupFragReq->noOfAttributeGroups;
+  Uint32 globalCheckpointIdIndicator = tupFragReq->globalCheckpointIdIndicator;
+
+  Uint64 maxRows =
+    (((Uint64)tupFragReq->maxRowsHigh) << 32) + tupFragReq->maxRowsLow;
+  Uint64 minRows =
+    (((Uint64)tupFragReq->minRowsHigh) << 32) + tupFragReq->minRowsLow;
 
 #ifndef VM_TRACE
   // config mismatch - do not crash if release compiled
   if (regTabPtr.i >= cnoOfTablerec) {
     ljam();
-    signal->theData[0] = userptr;
-    signal->theData[1] = 800;
+    tupFragReq->userPtr = userptr;
+    tupFragReq->userRef = 800;
     sendSignal(userblockref, GSN_TUPFRAGREF, signal, 2, JBB);
     return;
   }
@@ -83,8 +88,8 @@ void Dbtup::execTUPFRAGREQ(Signal* signal)
   ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec);
   if (cfirstfreeFragopr == RNIL) {
     ljam();
-    signal->theData[0] = userptr;
-    signal->theData[1] = ZNOFREE_FRAGOP_ERROR;
+    tupFragReq->userPtr = userptr;
+    tupFragReq->userRef = ZNOFREE_FRAGOP_ERROR;
     sendSignal(userblockref, GSN_TUPFRAGREF, signal, 2, JBB);
     return;
   }//if
@@ -100,6 +105,9 @@ void Dbtup::execTUPFRAGREQ(Signal* signal)
   fragOperPtr.p->noOfNewAttrCount = noOfNewAttr;
   fragOperPtr.p->charsetIndex = 0;
   fragOperPtr.p->currNullBit = 0;
+  // remove in 5.1, 2 fragments per fragment in 5.0
+  fragOperPtr.p->minRows = (minRows + 1)/2;
+  fragOperPtr.p->maxRows = (maxRows + 1)/2;
 
   ndbrequire(reqinfo == ZADDFRAG);
 
@@ -141,16 +149,6 @@ void Dbtup::execTUPFRAGREQ(Signal* signal)
   regFragPtr.p->fragmentId = fragId;
   regFragPtr.p->checkpointVersion = RNIL;
 
-  Uint32 noAllocatedPages = 2;
-  noAllocatedPages = allocFragPages(regFragPtr.p, noAllocatedPages);
-
-  if (noAllocatedPages == 0) {
-    ljam();
-    terrorCode = ZNO_PAGES_ALLOCATED_ERROR;
-    fragrefuse3Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId);
-    return;
-  }//if
-
   if (ERROR_INSERTED(4007) && regTabPtr.p->fragid[0] == fragId ||
       ERROR_INSERTED(4008) && regTabPtr.p->fragid[1] == fragId) {
     ljam();
@@ -407,6 +405,27 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
     CLEAR_ERROR_INSERT_VALUE;
     return;
   }
+
+  if (lastAttr)
+  {
+    ljam();
+    Uint32 noRowsPerPage = ZWORDS_ON_PAGE/regTabPtr.p->tupheadsize;
+    Uint32 noAllocatedPages =
+      (fragOperPtr.p->minRows + noRowsPerPage - 1 )/ noRowsPerPage;
+    if (fragOperPtr.p->minRows == 0)
+      noAllocatedPages = 2;
+    else if (noAllocatedPages == 0)
+      noAllocatedPages = 2;
+    noAllocatedPages = allocFragPages(regFragPtr.p, noAllocatedPages);
+
+    if (noAllocatedPages == 0) {
+      ljam();
+      terrorCode = ZNO_PAGES_ALLOCATED_ERROR;
+      addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId);
+      return;
+    }//if
+  }
+
 /* **************************************************************** */
 /* **************          TUP_ADD_ATTCONF       ****************** */
 /* **************************************************************** */
diff --git a/ndb/src/kernel/blocks/dbtup/DbtupPageMap.cpp b/ndb/src/kernel/blocks/dbtup/DbtupPageMap.cpp
index 1f674876642..acdb73704cb 100644
--- a/ndb/src/kernel/blocks/dbtup/DbtupPageMap.cpp
+++ b/ndb/src/kernel/blocks/dbtup/DbtupPageMap.cpp
@@ -332,6 +332,7 @@ void Dbtup::initFragRange(Fragrecord* const regFragPtr)
   regFragPtr->rootPageRange = RNIL;
   regFragPtr->currentPageRange = RNIL;
   regFragPtr->noOfPages = 0;
+  regFragPtr->noOfPagesToGrow = 2;
   regFragPtr->nextStartRange = 0;
 }//initFragRange()
 
@@ -393,9 +394,10 @@ Uint32 Dbtup::allocFragPages(Fragrecord* const regFragPtr, Uint32 tafpNoAllocReq
 
 void Dbtup::allocMoreFragPages(Fragrecord* const regFragPtr) 
 {
-  Uint32 noAllocPages = regFragPtr->noOfPages >> 3; // 12.5%
-  noAllocPages += regFragPtr->noOfPages >> 4; // 6.25%
+  Uint32 noAllocPages = regFragPtr->noOfPagesToGrow >> 3; // 12.5%
+  noAllocPages += regFragPtr->noOfPagesToGrow >> 4; // 6.25%
   noAllocPages += 2;
+  regFragPtr->noOfPagesToGrow += noAllocPages;
 /* -----------------------------------------------------------------*/
 // We will grow by 18.75% plus two more additional pages to grow
 // a little bit quicker in the beginning.
diff --git a/ndb/src/mgmsrv/MgmtSrvr.cpp b/ndb/src/mgmsrv/MgmtSrvr.cpp
index b9466ed1173..69c0286a1de 100644
--- a/ndb/src/mgmsrv/MgmtSrvr.cpp
+++ b/ndb/src/mgmsrv/MgmtSrvr.cpp
@@ -2380,14 +2380,20 @@ MgmtSrvr::startBackup(Uint32& backupId, int waitCompleted)
       event.Event = BackupEvent::BackupCompleted;
       event.Completed.BackupId = rep->backupId;
     
-      event.Completed.NoOfBytes = rep->noOfBytes;
+      event.Completed.NoOfBytes = rep->noOfBytesLow;
       event.Completed.NoOfLogBytes = rep->noOfLogBytes;
-      event.Completed.NoOfRecords = rep->noOfRecords;
+      event.Completed.NoOfRecords = rep->noOfRecordsLow;
       event.Completed.NoOfLogRecords = rep->noOfLogRecords;
       event.Completed.stopGCP = rep->stopGCP;
       event.Completed.startGCP = rep->startGCP;
       event.Nodes = rep->nodes;
 
+      if (signal->header.theLength >= BackupCompleteRep::SignalLength)
+      {
+        event.Completed.NoOfBytes += ((Uint64)rep->noOfBytesHigh) << 32;
+        event.Completed.NoOfRecords += ((Uint64)rep->noOfRecordsHigh) << 32;
+      }
+
       backupId = rep->backupId;
       return 0;
     }
diff --git a/ndb/src/mgmsrv/MgmtSrvr.hpp b/ndb/src/mgmsrv/MgmtSrvr.hpp
index 7811cf0e5d1..187f225470a 100644
--- a/ndb/src/mgmsrv/MgmtSrvr.hpp
+++ b/ndb/src/mgmsrv/MgmtSrvr.hpp
@@ -323,9 +323,9 @@ public:
 	Uint32 ErrorCode;
       } FailedToStart ;
       struct {
+	Uint64 NoOfBytes;
+	Uint64 NoOfRecords;
 	Uint32 BackupId;
-	Uint32 NoOfBytes;
-	Uint32 NoOfRecords;
 	Uint32 NoOfLogBytes;
 	Uint32 NoOfLogRecords;
 	Uint32 startGCP;
diff --git a/ndb/src/ndbapi/NdbDictionary.cpp b/ndb/src/ndbapi/NdbDictionary.cpp
index a342a5d5926..a0a3dd431b8 100644
--- a/ndb/src/ndbapi/NdbDictionary.cpp
+++ b/ndb/src/ndbapi/NdbDictionary.cpp
@@ -385,6 +385,30 @@ NdbDictionary::Table::getNoOfPrimaryKeys() const {
   return m_impl.m_noOfKeys;
 }
 
+void
+NdbDictionary::Table::setMaxRows(Uint64 maxRows)
+{
+  m_impl.m_max_rows = maxRows;
+}
+
+Uint64
+NdbDictionary::Table::getMaxRows() const
+{
+  return m_impl.m_max_rows;
+}
+
+void
+NdbDictionary::Table::setMinRows(Uint64 minRows)
+{
+  m_impl.m_min_rows = minRows;
+}
+
+Uint64
+NdbDictionary::Table::getMinRows() const
+{
+  return m_impl.m_min_rows;
+}
+
 const char*
 NdbDictionary::Table::getPrimaryKey(int no) const {
   int count = 0;
diff --git a/ndb/src/ndbapi/NdbDictionaryImpl.cpp b/ndb/src/ndbapi/NdbDictionaryImpl.cpp
index bd50440b3c0..ce348b616c9 100644
--- a/ndb/src/ndbapi/NdbDictionaryImpl.cpp
+++ b/ndb/src/ndbapi/NdbDictionaryImpl.cpp
@@ -319,6 +319,8 @@ NdbTableImpl::init(){
   m_noOfDistributionKeys= 0;
   m_noOfBlobs= 0;
   m_replicaCount= 0;
+  m_min_rows = 0;
+  m_max_rows = 0;
 }
 
 bool
@@ -416,6 +418,9 @@ NdbTableImpl::assign(const NdbTableImpl& org)
 
   m_version = org.m_version;
   m_status = org.m_status;
+
+  m_max_rows = org.m_max_rows;
+  m_min_rows = org.m_min_rows;
 }
 
 void NdbTableImpl::setName(const char * name)
@@ -1302,6 +1307,12 @@ NdbDictInterface::parseTableInfo(NdbTableImpl ** ret,
 		   fragmentTypeMapping, 
 		   (Uint32)NdbDictionary::Object::FragUndefined);
   
+  Uint64 max_rows = ((Uint64)tableDesc.MaxRowsHigh) << 32;
+  max_rows += tableDesc.MaxRowsLow;
+  impl->m_max_rows = max_rows;
+  Uint64 min_rows = ((Uint64)tableDesc.MinRowsHigh) << 32;
+  min_rows += tableDesc.MinRowsLow;
+  impl->m_min_rows = min_rows;
   impl->m_logging = tableDesc.TableLoggedFlag;
   impl->m_kvalue = tableDesc.TableKValue;
   impl->m_minLoadFactor = tableDesc.MinLoadFactor;
@@ -1630,7 +1641,16 @@ NdbDictInterface::createOrAlterTable(Ndb & ndb,
   tmpTab.MaxLoadFactor = impl.m_maxLoadFactor;
   tmpTab.TableType = DictTabInfo::UserTable;
   tmpTab.NoOfAttributes = sz;
+  tmpTab.MaxRowsHigh = (Uint32)(impl.m_max_rows >> 32);
+  tmpTab.MaxRowsLow = (Uint32)(impl.m_max_rows & 0xFFFFFFFF);
+  tmpTab.MinRowsHigh = (Uint32)(impl.m_min_rows >> 32);
+  tmpTab.MinRowsLow = (Uint32)(impl.m_min_rows & 0xFFFFFFFF);
   
+  Uint64 maxRows =
+    (((Uint64)tmpTab.MaxRowsHigh) << 32) + tmpTab.MaxRowsLow;
+  Uint64 minRows =
+    (((Uint64)tmpTab.MinRowsHigh) << 32) + tmpTab.MinRowsLow;
+
   tmpTab.FragmentType = getKernelConstant(impl.m_fragmentType,
 					  fragmentTypeMapping,
 					  DictTabInfo::AllNodesSmallTable);
diff --git a/ndb/src/ndbapi/NdbDictionaryImpl.hpp b/ndb/src/ndbapi/NdbDictionaryImpl.hpp
index bc9894497f8..dfccf120228 100644
--- a/ndb/src/ndbapi/NdbDictionaryImpl.hpp
+++ b/ndb/src/ndbapi/NdbDictionaryImpl.hpp
@@ -130,6 +130,9 @@ public:
   Uint32 m_hashpointerValue;
   Vector<Uint16> m_fragments;
 
+  Uint64 m_max_rows;
+  Uint64 m_min_rows;
+
   bool m_logging;
   int m_kvalue;
   int m_minLoadFactor;
diff --git a/ndb/tools/restore/Restore.cpp b/ndb/tools/restore/Restore.cpp
index 6ac06f8a6f8..a808a48b558 100644
--- a/ndb/tools/restore/Restore.cpp
+++ b/ndb/tools/restore/Restore.cpp
@@ -80,7 +80,12 @@ RestoreMetaData::RestoreMetaData(const char* path, Uint32 nodeId, Uint32 bNo) {
 
 RestoreMetaData::~RestoreMetaData(){
   for(Uint32 i= 0; i < allTables.size(); i++)
-    delete allTables[i];
+  {
+    TableS *table = allTables[i];
+    for(Uint32 j= 0; j < table->m_fragmentInfo.size(); j++)
+      delete table->m_fragmentInfo[j];
+    delete table;
+  }
   allTables.clear();
 }
 
@@ -111,6 +116,9 @@ RestoreMetaData::loadContent()
   }
   if(!readGCPEntry())
     return 0;
+
+  if(!readFragmentInfo())
+    return 0;
   return 1;
 }
 
@@ -192,6 +200,52 @@ RestoreMetaData::readGCPEntry() {
   return true;
 }
 
+bool
+RestoreMetaData::readFragmentInfo()
+{
+  BackupFormat::CtlFile::FragmentInfo fragInfo;
+  TableS * table = 0;
+  Uint32 tableId = RNIL;
+
+  while (buffer_read(&fragInfo, 4, 2) == 2)
+  {
+    fragInfo.SectionType = ntohl(fragInfo.SectionType);
+    fragInfo.SectionLength = ntohl(fragInfo.SectionLength);
+
+    if (fragInfo.SectionType != BackupFormat::FRAGMENT_INFO)
+    {
+      err << "readFragmentInfo invalid section type: " <<
+        fragInfo.SectionType << endl;
+      return false;
+    }
+
+    if (buffer_read(&fragInfo.TableId, (fragInfo.SectionLength-2)*4, 1) != 1)
+    {
+      err << "readFragmentInfo invalid section length: " <<
+        fragInfo.SectionLength << endl;
+      return false;
+    }
+
+    fragInfo.TableId = ntohl(fragInfo.TableId);
+    if (fragInfo.TableId != tableId)
+    {
+      tableId = fragInfo.TableId;
+      table = getTable(tableId);
+    }
+
+    FragmentInfo * tmp = new FragmentInfo;
+    tmp->fragmentNo = ntohl(fragInfo.FragmentNo);
+    tmp->noOfRecords = ntohl(fragInfo.NoOfRecordsLow) +
+      (((Uint64)ntohl(fragInfo.NoOfRecordsHigh)) << 32);
+    tmp->filePosLow = ntohl(fragInfo.FilePosLow);
+    tmp->filePosHigh = ntohl(fragInfo.FilePosHigh);
+
+    table->m_fragmentInfo.push_back(tmp);
+    table->m_noOfRecords += tmp->noOfRecords;
+  }
+  return true;
+}
+
 TableS::TableS(Uint32 version, NdbTableImpl* tableImpl)
   : m_dictTable(tableImpl)
 {
@@ -199,6 +253,7 @@ TableS::TableS(Uint32 version, NdbTableImpl* tableImpl)
   m_noOfNullable = m_nullBitmaskSize = 0;
   m_auto_val_id= ~(Uint32)0;
   m_max_auto_val= 0;
+  m_noOfRecords= 0;
   backupVersion = version;
   
   for (int i = 0; i < tableImpl->getNoOfColumns(); i++)
@@ -937,4 +992,5 @@ operator<<(NdbOut& ndbout, const TableS & table){
 template class Vector<TableS*>;
 template class Vector<AttributeS*>;
 template class Vector<AttributeDesc*>;
+template class Vector<FragmentInfo*>;
 
diff --git a/ndb/tools/restore/Restore.hpp b/ndb/tools/restore/Restore.hpp
index 85793baf9df..cf8feb7125c 100644
--- a/ndb/tools/restore/Restore.hpp
+++ b/ndb/tools/restore/Restore.hpp
@@ -114,6 +114,14 @@ public:
   AttributeData * getData(int i) const;
 }; // class TupleS
 
+struct FragmentInfo
+{
+  Uint32 fragmentNo;
+  Uint64 noOfRecords;
+  Uint32 filePosLow;
+  Uint32 filePosHigh;
+};
+
 class TableS {
   
   friend class TupleS;
@@ -136,6 +144,9 @@ class TableS {
 
   int pos;
 
+  Uint64 m_noOfRecords;
+  Vector<FragmentInfo *> m_fragmentInfo;
+
   void createAttr(NdbDictionary::Column *column);
 
 public:
@@ -146,6 +157,9 @@ public:
   Uint32 getTableId() const { 
     return m_dictTable->getTableId(); 
   }
+  Uint32 getNoOfRecords() const { 
+    return m_noOfRecords; 
+  }
   /*
   void setMysqlTableName(char * tableName) {
     strpcpy(mysqlTableName, tableName);
@@ -274,6 +288,7 @@ class RestoreMetaData : public BackupFile {
   bool readMetaTableDesc();
 		
   bool readGCPEntry();
+  bool readFragmentInfo();
   Uint32 readMetaTableList();
 
   Uint32 m_startGCP;
diff --git a/ndb/tools/restore/consumer_restore.cpp b/ndb/tools/restore/consumer_restore.cpp
index d62ca3f610a..bff63c28716 100644
--- a/ndb/tools/restore/consumer_restore.cpp
+++ b/ndb/tools/restore/consumer_restore.cpp
@@ -193,6 +193,16 @@ BackupRestore::table(const TableS & table){
 
     copy.setName(split[2].c_str());
 
+    /*
+      update min and max rows to reflect the table, this to
+      ensure that memory is allocated properly in the ndb kernel
+    */
+    copy.setMinRows(table.getNoOfRecords());
+    if (table.getNoOfRecords() > copy.getMaxRows())
+    {
+      copy.setMaxRows(table.getNoOfRecords());
+    }
+
     if (dict->createTable(copy) == -1) 
     {
       err << "Create table " << table.getTableName() << " failed: "