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

into  bodhi.local:/opt/local/work/mysql-5.0-runtime-merge-41

mysql-test/Makefile.am

@@ -101,15 +101,15 @@ uninstall-local:
 	@RM@ -f -r $(DESTDIR)$(testdir)
 
 std_data/client-key.pem: $(top_srcdir)/SSL/$(@F)
-	@CP@ -f $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
+	@RM@ -f $@; @CP@ $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
 std_data/client-cert.pem: $(top_srcdir)/SSL/$(@F)
-	@CP@ -f $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
+	@RM@ -f $@; @CP@ $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
 std_data/cacert.pem: $(top_srcdir)/SSL/$(@F)
-	@CP@ -f $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
+	@RM@ -f $@; @CP@ $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
 std_data/server-cert.pem: $(top_srcdir)/SSL/$(@F)
-	@CP@ -f $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
+	@RM@ -f $@; @CP@ $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
 std_data/server-key.pem: $(top_srcdir)/SSL/$(@F)
-	@CP@ -f $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
+	@RM@ -f $@; @CP@ $(top_srcdir)/SSL/$(@F) $(srcdir)/std_data
 
 SUFFIXES = .sh
 

ndb/include/kernel/GlobalSignalNumbers.h

@@ -587,6 +587,7 @@ extern const GlobalSignalNumber NO_OF_SIGNAL_NAMES;
 #define GSN_BLOCK_COMMIT_ORD            485
 #define GSN_UNBLOCK_COMMIT_ORD          486
 
+#define GSN_NODE_START_REP              502
 #define GSN_NODE_STATE_REP              487
 #define GSN_CHANGE_NODE_STATE_REQ       488
 #define GSN_CHANGE_NODE_STATE_CONF      489

ndb/src/common/debugger/signaldata/SignalNames.cpp

@@ -399,6 +399,8 @@ const GsnName SignalNames [] = {
   ,{ GSN_TUP_COM_UNBLOCK,        "TUP_COM_UNBLOCK" }
   ,{ GSN_DUMP_STATE_ORD,         "DUMP_STATE_ORD" }
 
+  ,{ GSN_NODE_START_REP, "NODE_START_REP" }
+
   ,{ GSN_START_INFOREQ,  "START_INFOREQ" }
   ,{ GSN_START_INFOREF,  "START_INFOREF" }
   ,{ GSN_START_INFOCONF, "START_INFOCONF" }

ndb/src/kernel/blocks/ERROR_codes.txt

@@ -2,7 +2,7 @@ Next QMGR 1
 Next NDBCNTR 1000
 Next NDBFS 2000
 Next DBACC 3002
-Next DBTUP 4013
+Next DBTUP 4014
 Next DBLQH 5043
 Next DBDICT 6007
 Next DBDIH 7177
@@ -437,6 +437,8 @@ Drop Table/Index:
 8036: Fail next index drop in TC
 6006: Crash participant in create index
 
+4013: verify TUP tab descr before and after next DROP TABLE
+
 System Restart:
 ---------------
 

ndb/src/kernel/blocks/dbdict/DictLock.txt

@@ -85,9 +85,13 @@ DIH/s
     START_MECONF
 DIH/s
 
-* sp7 - release DICT lock
+* (copy data, omitted)
 
-DIH/s
+* SL_STARTED - release DICT lock
+
+CNTR/s
+    NODE_START_REP
+        DIH/s
             DICT_UNLOCK_ORD
                 DICT/m
 

ndb/src/kernel/blocks/dbdih/Dbdih.hpp

@@ -1599,6 +1599,9 @@ private:
    */
   void startInfoReply(Signal *, Uint32 nodeId);
 
+  // DIH specifics for execNODE_START_REP (sendDictUnlockOrd)
+  void exec_node_start_rep(Signal* signal);
+
   /*
    * Lock master DICT.  Only current use is by starting node
    * during NR.  A pool of slave records is convenient anyway.

ndb/src/kernel/blocks/dbdih/DbdihMain.cpp

@@ -1356,24 +1356,6 @@ void Dbdih::execNDB_STTOR(Signal* signal)
     }
     ndbrequire(false);
     break;
-  case ZNDB_SPH7:
-    jam();
-    switch (typestart) {
-    case NodeState::ST_INITIAL_START:
-    case NodeState::ST_SYSTEM_RESTART:
-      jam();
-      ndbsttorry10Lab(signal, __LINE__);
-      return;
-    case NodeState::ST_NODE_RESTART:
-    case NodeState::ST_INITIAL_NODE_RESTART:
-      jam();
-      sendDictUnlockOrd(signal, c_dictLockSlavePtrI_nodeRestart);
-      c_dictLockSlavePtrI_nodeRestart = RNIL;
-      ndbsttorry10Lab(signal, __LINE__);
-      return;
-    }
-    ndbrequire(false);
-    break;
   default:
     jam();
     ndbsttorry10Lab(signal, __LINE__);
@@ -1381,6 +1363,27 @@ void Dbdih::execNDB_STTOR(Signal* signal)
   }//switch
 }//Dbdih::execNDB_STTOR()
 
+void
+Dbdih::exec_node_start_rep(Signal* signal)
+{
+  /*
+   * Send DICT_UNLOCK_ORD when this node is SL_STARTED.
+   *
+   * Sending it before (sp 7) conflicts with code which assumes
+   * SL_STARTING means we are in copy phase of NR.
+   *
+   * NodeState::starting.restartType is not supposed to be used
+   * when SL_STARTED.  Also it seems NODE_START_REP can arrive twice.
+   *
+   * For these reasons there are no consistency checks and
+   * we rely on c_dictLockSlavePtrI_nodeRestart alone.
+   */
+  if (c_dictLockSlavePtrI_nodeRestart != RNIL) {
+    sendDictUnlockOrd(signal, c_dictLockSlavePtrI_nodeRestart);
+    c_dictLockSlavePtrI_nodeRestart = RNIL;
+  }
+}
+
 void
 Dbdih::createMutexes(Signal * signal, Uint32 count){
   Callback c = { safe_cast(&Dbdih::createMutex_done), count };
@@ -1605,6 +1608,7 @@ void Dbdih::nodeRestartPh2Lab(Signal* signal)
 void Dbdih::recvDictLockConf_nodeRestart(Signal* signal, Uint32 data, Uint32 ret)
 {
   ndbrequire(c_dictLockSlavePtrI_nodeRestart == RNIL);
+  ndbrequire(data != RNIL);
   c_dictLockSlavePtrI_nodeRestart = data;
 
   nodeRestartPh2Lab2(signal);

ndb/src/kernel/blocks/dbtup/Dbtup.hpp

@@ -2185,15 +2185,18 @@ private:
 // Public methods
   Uint32 getTabDescrOffsets(const Tablerec* regTabPtr, Uint32* offset);
   Uint32 allocTabDescr(const Tablerec* regTabPtr, Uint32* offset);
-  void freeTabDescr(Uint32 retRef, Uint32 retNo);
+  void freeTabDescr(Uint32 retRef, Uint32 retNo, bool normal = true);
   Uint32 getTabDescrWord(Uint32 index);
   void setTabDescrWord(Uint32 index, Uint32 word);
 
 // Private methods
   Uint32 sizeOfReadFunction();
   void   removeTdArea(Uint32 tabDesRef, Uint32 list);
-  void   insertTdArea(Uint32 sizeOfChunk, Uint32 tabDesRef, Uint32 list);
-  Uint32 itdaMergeTabDescr(Uint32 retRef, Uint32 retNo);
+  void   insertTdArea(Uint32 tabDesRef, Uint32 list);
+  void   itdaMergeTabDescr(Uint32& retRef, Uint32& retNo, bool normal);
+#ifdef VM_TRACE
+  void verifytabdes();
+#endif
 
 //------------------------------------------------------------------------------------------------------
 // Page Memory Manager

ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp

@@ -601,6 +601,11 @@ void
 Dbtup::execDROP_TAB_REQ(Signal* signal)
 {
   ljamEntry();
+  if (ERROR_INSERTED(4013)) {
+#ifdef VM_TRACE
+    verifytabdes();
+#endif
+  }
   DropTabReq* req = (DropTabReq*)signal->getDataPtr();
   
   TablerecPtr tabPtr;
@@ -719,5 +724,11 @@ void Dbtup::execFSREMOVECONF(Signal* signal)
   
   releaseTabDescr(tabPtr.p);
   initTab(tabPtr.p);
+  if (ERROR_INSERTED(4013)) {
+    CLEAR_ERROR_INSERT_VALUE;
+#ifdef VM_TRACE
+    verifytabdes();
+#endif
+  }
 }//Dbtup::execFSREMOVECONF()
 

ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp

@@ -24,13 +24,15 @@
 #define ljam() { jamLine(22000 + __LINE__); }
 #define ljamEntry() { jamEntryLine(22000 + __LINE__); }
 
-/* **************************************************************** */
-/* *********** TABLE DESCRIPTOR MEMORY MANAGER ******************** */
-/* **************************************************************** */
-/* This module is used to allocate and deallocate table descriptor  */
-/* memory attached to fragments (could be allocated per table       */
-/* instead. Performs its task by a buddy algorithm.                 */
-/* **************************************************************** */
+/*
+ * TABLE DESCRIPTOR MEMORY MANAGER
+ *
+ * Each table has a descriptor which is a contiguous array of words.
+ * The descriptor is allocated from a global array using a buddy
+ * algorithm.  Free lists exist for each power of 2 words.  Freeing
+ * a piece first merges with free right and left neighbours and then
+ * divides itself up into free list chunks.
+ */
 
 Uint32
 Dbtup::getTabDescrOffsets(const Tablerec* regTabPtr, Uint32* offset)
@@ -59,7 +61,7 @@ Uint32 Dbtup::allocTabDescr(const Tablerec* regTabPtr, Uint32* offset)
   Uint32 reference = RNIL;
   Uint32 allocSize = getTabDescrOffsets(regTabPtr, offset);
 /* ---------------------------------------------------------------- */
-/*       ALWAYS ALLOCATE A MULTIPLE OF 16 BYTES                     */
+/*       ALWAYS ALLOCATE A MULTIPLE OF 16 WORDS                     */
 /* ---------------------------------------------------------------- */
   allocSize = (((allocSize - 1) >> 4) + 1) << 4;
   Uint32 list = nextHigherTwoLog(allocSize - 1);	/* CALCULATE WHICH LIST IT BELONGS TO     */
@@ -72,9 +74,9 @@ Uint32 Dbtup::allocTabDescr(const Tablerec* regTabPtr, Uint32* offset)
       Uint32 retNo = (1 << i) - allocSize;	        /* CALCULATE THE DIFFERENCE               */
       if (retNo >= ZTD_FREE_SIZE) {
         ljam();
-        Uint32 retRef = reference + allocSize;          /* SET THE RETURN POINTER                 */
-        retNo = itdaMergeTabDescr(retRef, retNo);       /* MERGE WITH POSSIBLE RIGHT NEIGHBOURS   */
-        freeTabDescr(retRef, retNo);	                /* RETURN UNUSED TD SPACE TO THE TD AREA  */
+        // return unused words, of course without attempting left merge
+        Uint32 retRef = reference + allocSize;
+        freeTabDescr(retRef, retNo, false);
       } else {
         ljam();
         allocSize = 1 << i;
@@ -100,17 +102,19 @@ Uint32 Dbtup::allocTabDescr(const Tablerec* regTabPtr, Uint32* offset)
   }//if
 }//Dbtup::allocTabDescr()
 
-void Dbtup::freeTabDescr(Uint32 retRef, Uint32 retNo) 
+void Dbtup::freeTabDescr(Uint32 retRef, Uint32 retNo, bool normal)
 {
+  itdaMergeTabDescr(retRef, retNo, normal);       /* MERGE WITH POSSIBLE NEIGHBOURS   */
   while (retNo >= ZTD_FREE_SIZE) {
     ljam();
     Uint32 list = nextHigherTwoLog(retNo);
     list--;	/* RETURN TO NEXT LOWER LIST    */
     Uint32 sizeOfChunk = 1 << list;
-    insertTdArea(sizeOfChunk, retRef, list);
+    insertTdArea(retRef, list);
     retRef += sizeOfChunk;
     retNo -= sizeOfChunk;
   }//while
+  ndbassert(retNo == 0);
 }//Dbtup::freeTabDescr()
 
 Uint32
@@ -127,7 +131,7 @@ Dbtup::setTabDescrWord(Uint32 index, Uint32 word)
   tableDescriptor[index].tabDescr = word;
 }//Dbtup::setTabDescrWord()
 
-void Dbtup::insertTdArea(Uint32 sizeOfChunk, Uint32 tabDesRef, Uint32 list) 
+void Dbtup::insertTdArea(Uint32 tabDesRef, Uint32 list) 
 {
   ndbrequire(list < 16);
   setTabDescrWord(tabDesRef + ZTD_FL_HEADER, ZTD_TYPE_FREE);
@@ -144,19 +148,14 @@ void Dbtup::insertTdArea(Uint32 sizeOfChunk, Uint32 tabDesRef, Uint32 list)
   setTabDescrWord((tabDesRef + (1 << list)) - ZTD_TR_SIZE, 1 << list);
 }//Dbtup::insertTdArea()
 
-/* ---------------------------------------------------------------- */
-/* ----------------------- MERGE_TAB_DESCR ------------------------ */
-/* ---------------------------------------------------------------- */
-/* INPUT:  TAB_DESCR_PTR   POINTING AT THE CURRENT CHUNK            */
-/*                                                                  */
-/* SHORTNAME:   MTD                                                 */
-/* -----------------------------------------------------------------*/
-Uint32 Dbtup::itdaMergeTabDescr(Uint32 retRef, Uint32 retNo) 
+/*
+ * Merge to-be-removed chunk (which need not be initialized with header
+ * and trailer) with left and right buddies.  The start point retRef
+ * moves to left and the size retNo increases to match the new chunk.
+ */
+void Dbtup::itdaMergeTabDescr(Uint32& retRef, Uint32& retNo, bool normal)
 {
-   /* THE SIZE OF THE PART TO MERGE MUST BE OF THE SAME SIZE AS THE INSERTED PART */
-   /* THIS IS TRUE EITHER IF ONE PART HAS THE SAME SIZE OR THE SUM OF BOTH PARTS  */
-   /* TOGETHER HAS THE SAME SIZE AS THE PART TO BE INSERTED                       */
-   /* FIND THE SIZES OF THE PARTS TO THE RIGHT OF THE PART TO BE REINSERTED */
+  // merge right
   while ((retRef + retNo) < cnoOfTabDescrRec) {
     ljam();
     Uint32 tabDesRef = retRef + retNo;
@@ -170,11 +169,28 @@ Uint32 Dbtup::itdaMergeTabDescr(Uint32 retRef, Uint32 retNo)
       removeTdArea(tabDesRef, list);
     } else {
       ljam();
-      return retNo;
-    }//if
-  }//while
-  ndbrequire((retRef + retNo) == cnoOfTabDescrRec);
-  return retNo;
+      break;
+    }
+  }
+  // merge left
+  const bool mergeLeft = normal;
+  while (mergeLeft && retRef > 0) {
+    ljam();
+    Uint32 trailerWord = getTabDescrWord(retRef - ZTD_TR_TYPE);
+    if (trailerWord == ZTD_TYPE_FREE) {
+      ljam();
+      Uint32 sizeOfMergedPart = getTabDescrWord(retRef - ZTD_TR_SIZE);
+      ndbrequire(retRef >= sizeOfMergedPart);
+      retRef -= sizeOfMergedPart;
+      retNo += sizeOfMergedPart;
+      Uint32 list = nextHigherTwoLog(sizeOfMergedPart - 1);
+      removeTdArea(retRef, list);
+    } else {
+      ljam();
+      break;
+    }
+  }
+  ndbrequire((retRef + retNo) <= cnoOfTabDescrRec);
 }//Dbtup::itdaMergeTabDescr()
 
 /* ---------------------------------------------------------------- */
@@ -210,3 +226,94 @@ void Dbtup::removeTdArea(Uint32 tabDesRef, Uint32 list)
     setTabDescrWord(tabDescrPrevPtr + ZTD_FL_NEXT, tabDescrNextPtr);
   }//if
 }//Dbtup::removeTdArea()
+
+#ifdef VM_TRACE
+void
+Dbtup::verifytabdes()
+{
+  struct WordType {
+    short fl;   // free list 0-15
+    short ti;   // table id
+    WordType() : fl(-1), ti(-1) {}
+  };
+  WordType* wt = new WordType [cnoOfTabDescrRec];
+  uint free_frags = 0;
+  // free lists
+  {
+    for (uint i = 0; i < 16; i++) {
+      Uint32 desc2 = RNIL;
+      Uint32 desc = cfreeTdList[i];
+      while (desc != RNIL) {
+        const Uint32 size = (1 << i);
+        ndbrequire(size >= ZTD_FREE_SIZE);
+        ndbrequire(desc + size <= cnoOfTabDescrRec);
+        { Uint32 index = desc + ZTD_FL_HEADER;
+          ndbrequire(tableDescriptor[index].tabDescr == ZTD_TYPE_FREE);
+        }
+        { Uint32 index = desc + ZTD_FL_SIZE;
+          ndbrequire(tableDescriptor[index].tabDescr == size);
+        }
+        { Uint32 index = desc + size - ZTD_TR_TYPE;
+          ndbrequire(tableDescriptor[index].tabDescr == ZTD_TYPE_FREE);
+        }
+        { Uint32 index = desc + size - ZTD_TR_SIZE;
+          ndbrequire(tableDescriptor[index].tabDescr == size);
+        }
+        { Uint32 index = desc + ZTD_FL_PREV;
+          ndbrequire(tableDescriptor[index].tabDescr == desc2);
+        }
+        for (uint j = 0; j < size; j++) {
+          ndbrequire(wt[desc + j].fl == -1);
+          wt[desc + j].fl = i;
+        }
+        desc2 = desc;
+        desc = tableDescriptor[desc + ZTD_FL_NEXT].tabDescr;
+        free_frags++;
+      }
+    }
+  }
+  // tables
+  {
+    for (uint i = 0; i < cnoOfTablerec; i++) {
+      TablerecPtr ptr;
+      ptr.i = i;
+      ptrAss(ptr, tablerec);
+      if (ptr.p->tableStatus == DEFINED) {
+        Uint32 offset[10];
+        const Uint32 alloc = getTabDescrOffsets(ptr.p, offset);
+        const Uint32 desc = ptr.p->readKeyArray - offset[3];
+        Uint32 size = alloc;
+        if (size % ZTD_FREE_SIZE != 0)
+          size += ZTD_FREE_SIZE - size % ZTD_FREE_SIZE;
+        ndbrequire(desc + size <= cnoOfTabDescrRec);
+        { Uint32 index = desc + ZTD_FL_HEADER;
+          ndbrequire(tableDescriptor[index].tabDescr == ZTD_TYPE_NORMAL);
+        }
+        { Uint32 index = desc + ZTD_FL_SIZE;
+          ndbrequire(tableDescriptor[index].tabDescr == size);
+        }
+        { Uint32 index = desc + size - ZTD_TR_TYPE;
+          ndbrequire(tableDescriptor[index].tabDescr == ZTD_TYPE_NORMAL);
+        }
+        { Uint32 index = desc + size - ZTD_TR_SIZE;
+          ndbrequire(tableDescriptor[index].tabDescr == size);
+        }
+        for (uint j = 0; j < size; j++) {
+          ndbrequire(wt[desc + j].ti == -1);
+          wt[desc + j].ti = i;
+        }
+      }
+    }
+  }
+  // all words
+  {
+    for (uint i = 0; i < cnoOfTabDescrRec; i++) {
+      bool is_fl = wt[i].fl != -1;
+      bool is_ti = wt[i].ti != -1;
+      ndbrequire(is_fl != is_ti);
+    }
+  }
+  delete [] wt;
+  ndbout << "verifytabdes: frags=" << free_frags << endl;
+}
+#endif

ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp

@@ -592,6 +592,13 @@ Ndbcntr::execCNTR_START_REP(Signal* signal){
   c_startedNodes.set(nodeId);
   c_start.m_starting.clear(nodeId);
 
+  /**
+   * Inform all interested blocks that node has started
+   */
+  for(Uint32 i = 0; i<ALL_BLOCKS_SZ; i++){
+    sendSignal(ALL_BLOCKS[i].Ref, GSN_NODE_START_REP, signal, 1, JBB);
+  }
+  
   if(!c_start.m_starting.isclear()){
     jam();
     return;

ndb/src/kernel/vm/SimulatedBlock.cpp

@@ -148,6 +148,7 @@ SimulatedBlock::installSimulatedBlockFunctions(){
   a[GSN_FSREMOVEREF]  = &SimulatedBlock::execFSREMOVEREF;
   a[GSN_FSSYNCREF]    = &SimulatedBlock::execFSSYNCREF;
   a[GSN_FSAPPENDREF]  = &SimulatedBlock::execFSAPPENDREF;
+  a[GSN_NODE_START_REP] = &SimulatedBlock::execNODE_START_REP;
 }
 
 void
@@ -913,6 +914,20 @@ SimulatedBlock::execCONTINUE_FRAGMENTED(Signal * signal){
   sendSignal(reference(), GSN_CONTINUE_FRAGMENTED, signal, 1, JBB);
 }
 
+void
+SimulatedBlock::execNODE_START_REP(Signal* signal)
+{
+  // common stuff for all blocks
+
+  // block specific stuff by virtual method override (default empty)
+  exec_node_start_rep(signal);
+}
+
+void
+SimulatedBlock::exec_node_start_rep(Signal* signal)
+{
+}
+
 #ifdef VM_TRACE_TIME
 void
 SimulatedBlock::clearTimes() {

ndb/src/kernel/vm/SimulatedBlock.hpp

@@ -423,6 +423,8 @@ private:
 
   void execSIGNAL_DROPPED_REP(Signal* signal);
   void execCONTINUE_FRAGMENTED(Signal* signal);
+  void execNODE_START_REP(Signal* signal);
+  virtual void exec_node_start_rep(Signal* signal);
 
   Uint32 c_fragmentIdCounter;
   ArrayPool<FragmentInfo> c_fragmentInfoPool;

ndb/test/ndbapi/testDict.cpp

@@ -233,6 +233,101 @@ int runCreateAndDrop(NDBT_Context* ctx, NDBT_Step* step){
   return NDBT_OK;
 }
 
+int runCreateAndDropAtRandom(NDBT_Context* ctx, NDBT_Step* step)
+{
+  myRandom48Init(NdbTick_CurrentMillisecond());
+  Ndb* pNdb = GETNDB(step);
+  NdbDictionary::Dictionary* pDic = pNdb->getDictionary();
+  int loops = ctx->getNumLoops();
+  int numTables = NDBT_Tables::getNumTables();
+  bool* tabList = new bool [ numTables ];
+  int tabCount;
+
+  {
+    for (int num = 0; num < numTables; num++) {
+      (void)pDic->dropTable(NDBT_Tables::getTable(num)->getName());
+      tabList[num] = false;
+    }
+    tabCount = 0;
+  }
+
+  NdbRestarter restarter;
+  int result = NDBT_OK;
+  int bias = 1; // 0-less 1-more
+  int i = 0;
+  
+  while (i < loops) {
+    g_info << "loop " << i << " tabs " << tabCount << "/" << numTables << endl;
+    int num = myRandom48(numTables);
+    const NdbDictionary::Table* pTab = NDBT_Tables::getTable(num);
+    char tabName[200];
+    strcpy(tabName, pTab->getName());
+
+    if (tabList[num] == false) {
+      if (bias == 0 && myRandom48(100) < 80)
+        continue;
+      g_info << tabName << ": create" << endl;
+      if (pDic->createTable(*pTab) != 0) {
+        const NdbError err = pDic->getNdbError();
+        g_err << tabName << ": create failed: " << err << endl;
+        result = NDBT_FAILED;
+        break;
+      }
+      const NdbDictionary::Table* pTab2 = pDic->getTable(tabName);
+      if (pTab2 == NULL) {
+        const NdbError err = pDic->getNdbError();
+        g_err << tabName << ": verify create: " << err << endl;
+        result = NDBT_FAILED;
+        break;
+      }
+      tabList[num] = true;
+      assert(tabCount < numTables);
+      tabCount++;
+      if (tabCount == numTables)
+        bias = 0;
+    }
+    else {
+      if (bias == 1 && myRandom48(100) < 80)
+        continue;
+      g_info << tabName << ": drop" << endl;
+      if (restarter.insertErrorInAllNodes(4013) != 0) {
+        g_err << "error insert failed" << endl;
+        result = NDBT_FAILED;
+        break;
+      }
+      if (pDic->dropTable(tabName) != 0) {
+        const NdbError err = pDic->getNdbError();
+        g_err << tabName << ": drop failed: " << err << endl;
+        result = NDBT_FAILED;
+        break;
+      }
+      const NdbDictionary::Table* pTab2 = pDic->getTable(tabName);
+      if (pTab2 != NULL) {
+        g_err << tabName << ": verify drop: table exists" << endl;
+        result = NDBT_FAILED;
+        break;
+      }
+      if (pDic->getNdbError().code != 709 &&
+          pDic->getNdbError().code != 723) {
+        const NdbError err = pDic->getNdbError();
+        g_err << tabName << ": verify drop: " << err << endl;
+        result = NDBT_FAILED;
+        break;
+      }
+      tabList[num] = false;
+      assert(tabCount > 0);
+      tabCount--;
+      if (tabCount == 0)
+        bias = 1;
+    }
+    i++;
+  }
+
+  delete [] tabList;
+  return result;
+}
+
+
 int runCreateAndDropWithData(NDBT_Context* ctx, NDBT_Step* step){
   Ndb* pNdb = GETNDB(step);
   int loops = ctx->getNumLoops();
@@ -1849,6 +1944,12 @@ TESTCASE("CreateAndDrop",
 	 "Try to create and drop the table loop number of times\n"){
   INITIALIZER(runCreateAndDrop);
 }
+TESTCASE("CreateAndDropAtRandom",
+	 "Try to create and drop table at random loop number of times\n"
+         "Uses all available tables\n"
+         "Uses error insert 4013 to make TUP verify table descriptor"){
+  INITIALIZER(runCreateAndDropAtRandom);
+}
 TESTCASE("CreateAndDropWithData", 
 	 "Try to create and drop the table when it's filled with data\n"
 	 "do this loop number of times\n"){

ndb/test/run-test/daily-basic-tests.txt

@@ -464,6 +464,10 @@ max-time: 1500
 cmd: testDict
 args: -n CreateAndDrop 
 
+max-time: 1500
+cmd: testDict
+args: -n CreateAndDropAtRandom -l 200 T1
+
 max-time: 1500
 cmd: testDict
 args: -n CreateAndDropWithData 
@@ -500,6 +504,10 @@ max-time: 1500
 cmd: testDict
 args: -n TemporaryTables T1 T6 T7 T8 
 
+max-time: 1500
+cmd: testDict
+args: -n Restart_NR2 T1
+
 #
 # TEST NDBAPI
 #

support-files/mysql.spec.sh

@@ -342,7 +342,7 @@ then
   cp -fp config.log "$MYSQL_MAXCONFLOG_DEST"
 fi
 
-make -i test-force || true
+make -i test-force-pl || true
 
 # Save mysqld-max
 ./libtool --mode=execute cp sql/mysqld sql/mysqld-max
@@ -401,7 +401,7 @@ then
   cp -fp config.log "$MYSQL_CONFLOG_DEST"
 fi
 
-make -i test-force || true
+make -i test-force-pl || true
 
 %install
 RBR=$RPM_BUILD_ROOT
@@ -740,6 +740,15 @@ fi
 # itself - note that they must be ordered by date (important when
 # merging BK trees)
 %changelog 
+* Mon Jul 10 2006 Joerg Bruehe <joerg@mysql.com>
+
+- Fix a typing error in the "make" target for the Perl script to run the tests.
+
+* Tue Jul 04 2006 Joerg Bruehe <joerg@mysql.com>
+
+- Use the Perl script to run the tests, because it will automatically check
+  whether the server is configured with SSL.
+
 * Tue Jun 27 2006 Joerg Bruehe <joerg@mysql.com>
 
 - move "mysqldumpslow" from the client RPM to the server RPM (bug#20216)