Merge mysql.com:/home/jonas/src/mysql-4.1-fix

into mysql.com:/home/jonas/src/wl1744


BitKeeper/etc/logging_ok:
  auto-union
configure.in:
  Auto merged
ndb/include/Makefile.am:
  Auto merged
ndb/src/common/mgmcommon/ConfigRetriever.cpp:
  Auto merged
ndb/src/common/util/version.c:
  Auto merged
ndb/src/kernel/blocks/dbdict/Dbdict.cpp:
  Auto merged
ndb/src/kernel/blocks/dbdict/Dbdict.hpp:
  Auto merged
ndb/src/kernel/blocks/dbdih/Dbdih.hpp:
  Auto merged
ndb/src/kernel/blocks/dbdih/DbdihMain.cpp:
  Auto merged
ndb/src/kernel/blocks/dbtc/DbtcMain.cpp:
  Auto merged
ndb/src/mgmsrv/main.cpp:
  Auto merged
ndb/src/ndbapi/NdbConnection.cpp:
  Auto merged
sql/ha_ndbcluster.cc:
  Auto merged

4 files changed, 263 insertions, 35 deletions

diff --git a/ndb/test/ndbapi/testDict.cpp b/ndb/test/ndbapi/testDict.cpp
index 9552e321f00..712ab2e4d25 100644
--- a/ndb/test/ndbapi/testDict.cpp
+++ b/ndb/test/ndbapi/testDict.cpp
@@ -1479,6 +1479,69 @@ runTestDictionaryPerf(NDBT_Context* ctx, NDBT_Step* step){
   return NDBT_OK;
 }
 
+int runFailAddFragment(NDBT_Context* ctx, NDBT_Step* step){
+  static int tuplst[] = { 4007, 4008, 4009, 4010, 4011, 4012 };
+  static int tuxlst[] = { 12001, 12002, 12003, 12004, 12005, 12006 };
+  static unsigned tupcnt = sizeof(tuplst)/sizeof(tuplst[0]);
+  static unsigned tuxcnt = sizeof(tuxlst)/sizeof(tuxlst[0]);
+
+  NdbRestarter restarter;
+  int nodeId = restarter.getMasterNodeId();
+  Ndb* pNdb = GETNDB(step);  
+  NdbDictionary::Dictionary* pDic = pNdb->getDictionary();
+  NdbDictionary::Table tab(*ctx->getTab());
+  tab.setFragmentType(NdbDictionary::Object::FragAllLarge);
+
+  // ordered index on first few columns
+  NdbDictionary::Index idx("X");
+  idx.setTable(tab.getName());
+  idx.setType(NdbDictionary::Index::OrderedIndex);
+  idx.setLogging(false);
+  for (int i_hate_broken_compilers = 0;
+       i_hate_broken_compilers < 3 &&
+       i_hate_broken_compilers < tab.getNoOfColumns();
+       i_hate_broken_compilers++) {
+    idx.addColumn(*tab.getColumn(i_hate_broken_compilers));
+  }
+
+  const int loops = ctx->getNumLoops();
+  int result = NDBT_OK;
+  (void)pDic->dropTable(tab.getName());
+
+  for (int l = 0; l < loops; l++) {
+    for (unsigned i1 = 0; i1 < tupcnt; i1++) {
+      unsigned j = (l == 0 ? i1 : myRandom48(tupcnt));
+      int errval = tuplst[j];
+      g_info << "insert error node=" << nodeId << " value=" << errval << endl;
+      CHECK2(restarter.insertErrorInNode(nodeId, errval) == 0,
+             "failed to set error insert");
+      CHECK2(pDic->createTable(tab) != 0,
+             "failed to fail after error insert " << errval);
+      CHECK2(pDic->createTable(tab) == 0,
+             pDic->getNdbError());
+      CHECK2(pDic->dropTable(tab.getName()) == 0,
+             pDic->getNdbError());
+    }
+    for (unsigned i2 = 0; i2 < tuxcnt; i2++) {
+      unsigned j = (l == 0 ? i2 : myRandom48(tuxcnt));
+      int errval = tuxlst[j];
+      g_info << "insert error node=" << nodeId << " value=" << errval << endl;
+      CHECK2(restarter.insertErrorInNode(nodeId, errval) == 0,
+             "failed to set error insert");
+      CHECK2(pDic->createTable(tab) == 0,
+             pDic->getNdbError());
+      CHECK2(pDic->createIndex(idx) != 0,
+             "failed to fail after error insert " << errval);
+      CHECK2(pDic->createIndex(idx) == 0,
+             pDic->getNdbError());
+      CHECK2(pDic->dropTable(tab.getName()) == 0,
+             pDic->getNdbError());
+    }
+  }
+end:
+  return result;
+}
+
 NDBT_TESTSUITE(testDict);
 TESTCASE("CreateAndDrop", 
 	 "Try to create and drop the table loop number of times\n"){
@@ -1574,6 +1637,10 @@ TESTCASE("DictionaryPerf",
 	 ""){
   INITIALIZER(runTestDictionaryPerf);
 }
+TESTCASE("FailAddFragment",
+         "Fail add fragment or attribute in TUP or TUX\n"){
+  INITIALIZER(runFailAddFragment);
+}
 NDBT_TESTSUITE_END(testDict);
 
 int main(int argc, const char** argv){
diff --git a/ndb/test/ndbapi/testReadPerf.cpp b/ndb/test/ndbapi/testReadPerf.cpp
index 380a809ad00..3adcb5a2d9b 100644
--- a/ndb/test/ndbapi/testReadPerf.cpp
+++ b/ndb/test/ndbapi/testReadPerf.cpp
@@ -391,8 +391,15 @@ run_read(){
 
 void
 print_result(){
+  int tmp = 1;
+  tmp *= g_paramters[P_RANGE].value;
+  tmp *= g_paramters[P_LOOPS].value;
+
+  int t, t2;
   for(int i = 0; i<P_OP_TYPES; i++){
-    g_err.println("%s avg: %u us/row", g_ops[i],
-		  (1000*g_times[i])/(g_paramters[P_RANGE].value*g_paramters[P_LOOPS].value));
+    g_err << g_ops[i] << " avg: "
+	  << (int)((1000*g_times[i])/tmp)
+	  << " us/row (" 
+	  << (1000 * tmp)/g_times[i] << " rows / sec)" << endl;
   }
 }
diff --git a/ndb/test/ndbapi/testScan.cpp b/ndb/test/ndbapi/testScan.cpp
index 0cd30dfefde..22ec3fff327 100644
--- a/ndb/test/ndbapi/testScan.cpp
+++ b/ndb/test/ndbapi/testScan.cpp
@@ -90,11 +90,59 @@ int runLoadAllTables(NDBT_Context* ctx, NDBT_Step* step){
   return NDBT_OK;
 }
 
+char orderedPkIdxName[255];
+
+int createOrderedPkIndex(NDBT_Context* ctx, NDBT_Step* step){
+
+  const NdbDictionary::Table* pTab = ctx->getTab();
+  Ndb* pNdb = GETNDB(step);
+  
+  // Create index    
+  BaseString::snprintf(orderedPkIdxName, sizeof(orderedPkIdxName), 
+		       "IDC_O_PK_%s", pTab->getName());
+  NdbDictionary::Index pIdx(orderedPkIdxName);
+  pIdx.setTable(pTab->getName());
+  pIdx.setType(NdbDictionary::Index::OrderedIndex);
+  pIdx.setLogging(false);
+
+  for (int c = 0; c< pTab->getNoOfColumns(); c++){
+    const NdbDictionary::Column * col = pTab->getColumn(c);
+    if(col->getPrimaryKey()){
+      pIdx.addIndexColumn(col->getName());
+    }
+  }
+  
+  if (pNdb->getDictionary()->createIndex(pIdx) != 0){
+    ndbout << "FAILED! to create index" << endl;
+    const NdbError err = pNdb->getDictionary()->getNdbError();
+    ERR(err);
+    return NDBT_FAILED;
+  }
+  
+  return NDBT_OK;
+}
+
+int createOrderedPkIndex_Drop(NDBT_Context* ctx, NDBT_Step* step){
+  const NdbDictionary::Table* pTab = ctx->getTab();
+  Ndb* pNdb = GETNDB(step);
+  
+  // Drop index
+  if (pNdb->getDictionary()->dropIndex(orderedPkIdxName, 
+				       pTab->getName()) != 0){
+    ndbout << "FAILED! to drop index" << endl;
+    ERR(pNdb->getDictionary()->getNdbError());
+    return NDBT_FAILED;
+  }
+  
+  return NDBT_OK;
+}
+
+
 int runScanReadRandomTable(NDBT_Context* ctx, NDBT_Step* step){
   int loops = ctx->getNumLoops();
   int records = ctx->getNumRecords();
   int parallelism = ctx->getProperty("Parallelism", 240);
-  int abort = ctx->getProperty("AbortProb");
+  int abort = ctx->getProperty("AbortProb", 5);
   
   int i = 0;
   while (i<loops) {
@@ -218,7 +266,7 @@ int runScanRead(NDBT_Context* ctx, NDBT_Step* step){
   int loops = ctx->getNumLoops();
   int records = ctx->getNumRecords();
   int parallelism = ctx->getProperty("Parallelism", 240);
-  int abort = ctx->getProperty("AbortProb");
+  int abort = ctx->getProperty("AbortProb", 5);
 
   int i = 0;
   HugoTransactions hugoTrans(*ctx->getTab());
@@ -232,18 +280,66 @@ int runScanRead(NDBT_Context* ctx, NDBT_Step* step){
   return NDBT_OK;
 }
 
+int runRandScanRead(NDBT_Context* ctx, NDBT_Step* step){
+  int loops = ctx->getNumLoops();
+  int records = ctx->getNumRecords();
+  int parallelism = ctx->getProperty("Parallelism", 240);
+  int abort = ctx->getProperty("AbortProb", 5);
+
+  int i = 0;
+  HugoTransactions hugoTrans(*ctx->getTab());
+  while (i<loops && !ctx->isTestStopped()) {
+    g_info << i << ": ";
+    NdbOperation::LockMode lm = (NdbOperation::LockMode)(rand() % 3);
+    if (hugoTrans.scanReadRecords(GETNDB(step),
+				  records, abort, parallelism,
+				  lm) != 0){
+      return NDBT_FAILED;
+    }
+    i++;
+  }
+  return NDBT_OK;
+}
+
+int runScanReadIndex(NDBT_Context* ctx, NDBT_Step* step){
+  int loops = ctx->getNumLoops();
+  int records = ctx->getNumRecords();
+  int parallelism = ctx->getProperty("Parallelism", 240);
+  int abort = ctx->getProperty("AbortProb", 5);
+  const NdbDictionary::Index * pIdx = 
+    GETNDB(step)->getDictionary()->getIndex(orderedPkIdxName, 
+					    ctx->getTab()->getName());
+
+  int i = 0;
+  HugoTransactions hugoTrans(*ctx->getTab());
+  while (pIdx && i<loops && !ctx->isTestStopped()) {
+    g_info << i << ": ";
+    bool sort = (rand() % 100) > 50 ? true : false;
+    NdbOperation::LockMode lm = (NdbOperation::LockMode)(rand() % 3);
+    if (hugoTrans.scanReadRecords(GETNDB(step), pIdx,
+				  records, abort, parallelism,
+				  lm,
+				  sort) != 0){
+      return NDBT_FAILED;
+    }
+    i++;
+  }
+  return NDBT_OK;
+}
+
 int runScanReadCommitted(NDBT_Context* ctx, NDBT_Step* step){
   int loops = ctx->getNumLoops();
   int records = ctx->getNumRecords();
   int parallelism = ctx->getProperty("Parallelism", 240);
-  int abort = ctx->getProperty("AbortProb");
+  int abort = ctx->getProperty("AbortProb", 5);
 
   int i = 0;
   HugoTransactions hugoTrans(*ctx->getTab());
   while (i<loops && !ctx->isTestStopped()) {
     g_info << i << ": ";
-    if (hugoTrans.scanReadCommittedRecords(GETNDB(step), records, 
-					   abort, parallelism) != 0){
+    if (hugoTrans.scanReadRecords(GETNDB(step), records, 
+				  abort, parallelism, 
+				  NdbOperation::LM_CommittedRead) != 0){
       return NDBT_FAILED;
     }
     i++;
@@ -424,7 +520,7 @@ int runScanUpdate(NDBT_Context* ctx, NDBT_Step* step){
   int loops = ctx->getNumLoops();
   int records = ctx->getNumRecords();
   int parallelism = ctx->getProperty("Parallelism", 1);
-  int abort = ctx->getProperty("AbortProb");
+  int abort = ctx->getProperty("AbortProb", 5);
   int i = 0;
   HugoTransactions hugoTrans(*ctx->getTab());
   while (i<loops) {
@@ -464,7 +560,7 @@ int runScanUpdate2(NDBT_Context* ctx, NDBT_Step* step){
   int loops = ctx->getNumLoops();
   int records = ctx->getNumRecords();
   int parallelism = ctx->getProperty("Parallelism", 240);
-  int abort = ctx->getProperty("AbortProb");
+  int abort = ctx->getProperty("AbortProb", 5);
   int i = 0;
   HugoTransactions hugoTrans(*ctx->getTab());
   while (i<loops) {
@@ -639,7 +735,7 @@ int runCheckGetValue(NDBT_Context* ctx, NDBT_Step* step){
     g_info << (unsigned)i << endl;
     if(utilTrans.scanReadRecords(GETNDB(step), 
 				 parallelism,
-				 false,
+				 NdbOperation::LM_Read,
 				 records,
 				 alist.attriblist[i]->numAttribs,
 				 alist.attriblist[i]->attribs) != 0){
@@ -647,7 +743,7 @@ int runCheckGetValue(NDBT_Context* ctx, NDBT_Step* step){
     }
     if(utilTrans.scanReadRecords(GETNDB(step), 
 				 parallelism,
-				 true,
+				 NdbOperation::LM_Read,
 				 records,
 				 alist.attriblist[i]->numAttribs,
 				 alist.attriblist[i]->attribs) != 0){
@@ -1079,7 +1175,30 @@ TESTCASE("ScanRead488",
 	 "When this limit is exceeded the scan will be aborted with errorcode "\
 	 "488."){
   INITIALIZER(runLoadTable);
-  STEPS(runScanRead, 70);
+  STEPS(runRandScanRead, 70);
+  FINALIZER(runClearTable);
+}
+TESTCASE("ScanRead488O", 
+	 "Verify scan requirement: It's only possible to have 11 concurrent "\
+	 "scans per fragment running in Ndb kernel at the same time. "\
+	 "When this limit is exceeded the scan will be aborted with errorcode "\
+	 "488."){
+  INITIALIZER(createOrderedPkIndex);
+  INITIALIZER(runLoadTable);
+  STEPS(runScanReadIndex, 70);
+  FINALIZER(createOrderedPkIndex_Drop);
+  FINALIZER(runClearTable);
+}
+TESTCASE("ScanRead488_Mixed", 
+	 "Verify scan requirement: It's only possible to have 11 concurrent "\
+	 "scans per fragment running in Ndb kernel at the same time. "\
+	 "When this limit is exceeded the scan will be aborted with errorcode "\
+	 "488."){
+  INITIALIZER(createOrderedPkIndex);
+  INITIALIZER(runLoadTable);
+  STEPS(runRandScanRead, 50);
+  STEPS(runScanReadIndex, 50);
+  FINALIZER(createOrderedPkIndex_Drop);
   FINALIZER(runClearTable);
 }
 TESTCASE("ScanRead488Timeout", 
diff --git a/ndb/test/ndbapi/testScanPerf.cpp b/ndb/test/ndbapi/testScanPerf.cpp
index 003fc67179f..45f0468bc70 100644
--- a/ndb/test/ndbapi/testScanPerf.cpp
+++ b/ndb/test/ndbapi/testScanPerf.cpp
@@ -39,8 +39,9 @@ struct Parameter {
 #define P_LOOPS   8
 #define P_CREATE  9
 #define P_LOAD   10
+#define P_RESET  11
 
-#define P_MAX 11
+#define P_MAX 12
 
 static 
 Parameter 
@@ -55,7 +56,8 @@ g_paramters[] = {
   { "size",  1000000, 1, ~0 },
   { "iterations",  3, 1, ~0 },
   { "create_drop", 1, 0, 1 },
-  { "data",        1, 0, 1 }
+  { "data",        1, 0, 1 },
+  { "q-reset bounds", 0, 1, 0 }
 };
 
 static Ndb* g_ndb = 0;
@@ -219,21 +221,30 @@ run_scan(){
   NDB_TICKS start1, stop;
   int sum_time= 0;
 
+  int sample_rows = 0;
+  int tot_rows = 0;
+  NDB_TICKS sample_start = NdbTick_CurrentMillisecond();
+
   Uint32 tot = g_paramters[P_ROWS].value;
 
+  if(g_paramters[P_BOUND].value == 2 || g_paramters[P_FILT].value == 2)
+    iter *= g_paramters[P_ROWS].value;
+
+  NdbScanOperation * pOp = 0;
+  NdbIndexScanOperation * pIOp = 0;
+  NdbConnection * pTrans = 0;
+  NdbResultSet * rs = 0;
+  int check = 0;
+
   for(int i = 0; i<iter; i++){
     start1 = NdbTick_CurrentMillisecond();
-    NdbConnection * pTrans = g_ndb->startTransaction();
+    pTrans = pTrans ? pTrans : g_ndb->startTransaction();
     if(!pTrans){
       g_err << "Failed to start transaction" << endl;
       err(g_ndb->getNdbError());
       return -1;
     }
     
-    NdbScanOperation * pOp;
-    NdbIndexScanOperation * pIOp;
-
-    NdbResultSet * rs;
     int par = g_paramters[P_PARRA].value;
     int bat = g_paramters[P_BATCH].value;
     NdbScanOperation::LockMode lm;
@@ -256,9 +267,17 @@ run_scan(){
       assert(pOp);
       rs = pOp->readTuples(lm, bat, par);
     } else {
-      pOp = pIOp = pTrans->getNdbIndexScanOperation(g_indexname, g_tablename);
-      bool ord = g_paramters[P_ACCESS].value == 2;
-      rs = pIOp->readTuples(lm, bat, par, ord);
+      if(g_paramters[P_RESET].value == 0 || pIOp == 0)
+      {
+	pOp= pIOp= pTrans->getNdbIndexScanOperation(g_indexname, g_tablename);
+	bool ord = g_paramters[P_ACCESS].value == 2;
+	rs = pIOp->readTuples(lm, bat, par, ord);
+      }
+      else
+      {
+	pIOp->reset_bounds();
+      }
+
       switch(g_paramters[P_BOUND].value){
       case 0: // All
 	break;
@@ -268,20 +287,22 @@ run_scan(){
       case 2: { // 1 row
       default:  
 	assert(g_table->getNoOfPrimaryKeys() == 1); // only impl. so far
-	abort();
-#if 0
 	int tot = g_paramters[P_ROWS].value;
 	int row = rand() % tot;
+#if 0
 	fix_eq_bound(pIOp, row);
+#else
+	pIOp->setBound((Uint32)0, NdbIndexScanOperation::BoundEQ, &row);
 #endif
 	break;
       }
       }
+      if(g_paramters[P_RESET].value == 2)
+	goto execute;
     }
     assert(pOp);
     assert(rs);
     
-    int check = 0;
     switch(g_paramters[P_FILT].value){
     case 0: // All
       check = pOp->interpret_exit_ok();
@@ -310,10 +331,13 @@ run_scan(){
     }
     assert(check == 0);
 
+    if(g_paramters[P_RESET].value == 1)
+      g_paramters[P_RESET].value = 2;
+    
     for(int i = 0; i<g_table->getNoOfColumns(); i++){
       pOp->getValue(i);
     }
-
+execute:
     int rows = 0;
     check = pTrans->execute(NoCommit);
     assert(check == 0);
@@ -334,19 +358,30 @@ run_scan(){
       return -1;
     }
     assert(check == 1);
-    g_info << "Found " << rows << " rows" << endl;
-
-    pTrans->close();
-
+    if(g_paramters[P_RESET].value == 0)
+    {
+      pTrans->close();
+      pTrans = 0;
+    }
     stop = NdbTick_CurrentMillisecond();
+    
     int time_passed= (int)(stop - start1);
-    g_err.println("Time: %d ms = %u rows/sec", time_passed,
-                  (1000*tot)/time_passed);
+    sample_rows += rows;
     sum_time+= time_passed;
+    tot_rows+= rows;
+    
+    if(sample_rows >= tot)
+    {
+      int sample_time = (int)(stop - sample_start);
+      g_info << "Found " << sample_rows << " rows" << endl;
+      g_err.println("Time: %d ms = %u rows/sec", sample_time,
+		    (1000*sample_rows)/sample_time);
+      sample_rows = 0;
+      sample_start = stop;
+    }
   }
-  sum_time= sum_time / iter;
   
-  g_err.println("Avg time: %d ms = %u rows/sec", sum_time,
-                (1000*tot)/sum_time);
+  g_err.println("Avg time: %d ms = %u rows/sec", sum_time/tot_rows,
+                (1000*tot_rows)/sum_time);
   return 0;
 }