开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
testIndex.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：45k
源码类别：

MySQL数据库

开发平台：

Visual C++

testIndex.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #include <NDBT.hpp>
  18. #include <NDBT_Test.hpp>
  19. #include <HugoTransactions.hpp>
  20. #include <UtilTransactions.hpp>
  21. #include <NdbRestarter.hpp>
  22. #include <NdbRestarts.hpp>
  23. #include <Vector.hpp>
  24. #include <signaldata/DumpStateOrd.hpp>
  26. #define CHECK(b) if (!(b)) { 
  27.   g_err << "ERR: "<< step->getName() 
  28.          << " failed on line " << __LINE__ << endl; 
  29.   result = NDBT_FAILED; break;
  30. } 
  33. struct Attrib {
  34.   bool indexCreated;
  35.   int numAttribs;
  36.   int attribs[1024];
  37.   Attrib(){
  38.     numAttribs = 0;
  39.     indexCreated = false;
  40.   }
  41. };
  42. class AttribList {
  43. public:
  44.   AttribList(){};
  45.   ~AttribList(){
  46.     for(size_t i = 0; i < attriblist.size(); i++){      
  47.       delete attriblist[i];
  48.     }
  49.   };
  50.   void buildAttribList(const NdbDictionary::Table* pTab); 
  51.   Vector<Attrib*> attriblist;
  52. };
  54. void AttribList::buildAttribList(const NdbDictionary::Table* pTab){
  55.   attriblist.clear();
  57.   Attrib* attr;
  58.   // Build attrib definitions that describes which attributes to build index
  59.   // Try to build strange combinations, not just "all" or all PK's
  61.   int i;
  63.   for(i = 1; i <= pTab->getNoOfColumns(); i++){
  64.     attr = new Attrib;
  65.     attr->numAttribs = i;
  66.     for(int a = 0; a<i; a++)
  67.       attr->attribs[a] = a;
  68.     attriblist.push_back(attr);
  69.   }
  70.   int b = 0;
  71.   for(i = pTab->getNoOfColumns()-1; i > 0; i--){
  72.     attr = new Attrib;
  73.     attr->numAttribs = i;
  74.     b++;
  75.     for(int a = 0; a<i; a++)
  76.       attr->attribs[a] = a+b;
  77.     attriblist.push_back(attr);
  78.   }
  79.   for(i = pTab->getNoOfColumns(); i > 0;  i--){
  80.     attr = new Attrib;
  81.     attr->numAttribs = pTab->getNoOfColumns() - i;
  82.     for(int a = 0; a<pTab->getNoOfColumns() - i; a++)
  83.       attr->attribs[a] = pTab->getNoOfColumns()-a-1;
  84.     attriblist.push_back(attr); 
  85.   }  
  86.   for(i = 1; i < pTab->getNoOfColumns(); i++){
  87.     attr = new Attrib;
  88.     attr->numAttribs = pTab->getNoOfColumns() - i;
  89.     for(int a = 0; a<pTab->getNoOfColumns() - i; a++)
  90.       attr->attribs[a] = pTab->getNoOfColumns()-a-1;
  91.     attriblist.push_back(attr); 
  92.   }  
  93.   for(i = 1; i < pTab->getNoOfColumns(); i++){
  94.     attr = new Attrib;
  95.     attr->numAttribs = 2;
  96.     for(int a = 0; a<2; a++){
  97.       attr->attribs[a] = i%pTab->getNoOfColumns();
  98.     }
  99.     attriblist.push_back(attr);
  100.   }
  102.   // Last 
  103.   attr = new Attrib;
  104.   attr->numAttribs = 1;
  105.   attr->attribs[0] = pTab->getNoOfColumns()-1;
  106.   attriblist.push_back(attr);
  108.   // Last and first
  109.   attr = new Attrib;
  110.   attr->numAttribs = 2;
  111.   attr->attribs[0] = pTab->getNoOfColumns()-1;
  112.   attr->attribs[1] = 0;
  113.   attriblist.push_back(attr); 
  115.   // First and last
  116.   attr = new Attrib;
  117.   attr->numAttribs = 2;
  118.   attr->attribs[0] = 0;
  119.   attr->attribs[1] = pTab->getNoOfColumns()-1;
  120.   attriblist.push_back(attr);  
  122. #if 0
  123.   for(size_t i = 0; i < attriblist.size(); i++){
  125.     ndbout << attriblist[i]->numAttribs << ": " ;
  126.     for(int a = 0; a < attriblist[i]->numAttribs; a++)
  127.       ndbout << attriblist[i]->attribs[a] << ", ";
  128.     ndbout << endl;
  129.   }
  130. #endif
  132. }
  134. char idxName[255];
  135. char pkIdxName[255];
  137. static const int SKIP_INDEX = 99;
  139. int create_index(NDBT_Context* ctx, int indxNum, 
  140.  const NdbDictionary::Table* pTab, 
  141.  Ndb* pNdb, Attrib* attr, bool logged){
  142.   bool orderedIndex = ctx->getProperty("OrderedIndex", (unsigned)0);
  143.   int result  = NDBT_OK;
  145.   HugoCalculator calc(*pTab);
  147.   if (attr->numAttribs == 1 && 
  148.       calc.isUpdateCol(attr->attribs[0]) == true){
  149.     // Don't create index for the Hugo update column
  150.     // since it's not unique
  151.     return SKIP_INDEX;
  152.   }
  154.   // Create index    
  155.   BaseString::snprintf(idxName, 255, "IDC%d", indxNum);
  156.   if (orderedIndex)
  157.     ndbout << "Creating " << ((logged)?"logged ": "temporary ") << "ordered index "<<idxName << " (";
  158.   else
  159.     ndbout << "Creating " << ((logged)?"logged ": "temporary ") << "unique index "<<idxName << " (";
  160.   ndbout << flush;
  161.   NdbDictionary::Index pIdx(idxName);
  162.   pIdx.setTable(pTab->getName());
  163.   if (orderedIndex)
  164.     pIdx.setType(NdbDictionary::Index::OrderedIndex);
  165.   else
  166.     pIdx.setType(NdbDictionary::Index::UniqueHashIndex);
  167.   for (int c = 0; c< attr->numAttribs; c++){
  168.     int attrNo = attr->attribs[c];
  169.     pIdx.addIndexColumn(pTab->getColumn(attrNo)->getName());
  170.     ndbout << pTab->getColumn(attrNo)->getName()<<" ";
  171.   }
  172.   
  173.   pIdx.setStoredIndex(logged);
  174.   ndbout << ") ";
  175.   if (pNdb->getDictionary()->createIndex(pIdx) != 0){
  176.     attr->indexCreated = false;
  177.     ndbout << "FAILED!" << endl;
  178.     const NdbError err = pNdb->getDictionary()->getNdbError();
  179.     ERR(err);
  180.     if(err.classification == NdbError::ApplicationError)
  181.       return SKIP_INDEX;
  182.     
  183.     return NDBT_FAILED;
  184.   } else {
  185.     ndbout << "OK!" << endl;
  186.     attr->indexCreated = true;
  187.   }
  188.   return result;
  189. }
  192. int drop_index(int indxNum, Ndb* pNdb, 
  193.        const NdbDictionary::Table* pTab, Attrib* attr){
  194.   int result = NDBT_OK;
  196.   if (attr->indexCreated == false)
  197.     return NDBT_OK;
  199.   BaseString::snprintf(idxName, 255, "IDC%d", indxNum);
  200.   
  201.   // Drop index
  202.   ndbout << "Dropping index "<<idxName<<"(" << pTab->getName() << ") ";
  203.   if (pNdb->getDictionary()->dropIndex(idxName, pTab->getName()) != 0){
  204.     ndbout << "FAILED!" << endl;
  205.     ERR(pNdb->getDictionary()->getNdbError());
  206.     result = NDBT_FAILED;
  207.   } else {
  208.     ndbout << "OK!" << endl;
  209.   }
  210.   return result;
  211. }
  213. int runCreateIndexes(NDBT_Context* ctx, NDBT_Step* step){
  214.   int loops = ctx->getNumLoops();
  215.   int l = 0;
  216.   const NdbDictionary::Table* pTab = ctx->getTab();
  217.   Ndb* pNdb = GETNDB(step);
  218.   int result = NDBT_OK;
  219.   // NOTE If we need to test creating both logged and non logged indexes
  220.   // this should be divided into two testcases
  221.   // The paramater logged should then be specified 
  222.   // as a TC_PROPERTY. ex TC_PROPERTY("LoggedIndexes", 1);
  223.   // and read into the test step like
  224.   bool logged = ctx->getProperty("LoggedIndexes", 1);
  226.   AttribList attrList;
  227.   attrList.buildAttribList(pTab);
  230.   while (l < loops && result == NDBT_OK){
  231.     unsigned int i;
  232.     for (i = 0; i < attrList.attriblist.size(); i++){
  233.       
  234.       // Try to create index
  235.       if (create_index(ctx, i, pTab, pNdb, attrList.attriblist[i], logged) == NDBT_FAILED)
  236. result = NDBT_FAILED;      
  237.     }
  238.     
  239.     // Now drop all indexes that where created
  240.     for (i = 0; i < attrList.attriblist.size(); i++){
  241.             
  242.       // Try to drop index
  243.       if (drop_index(i, pNdb, pTab, attrList.attriblist[i]) != NDBT_OK)
  244. result = NDBT_FAILED;            
  245.     }
  246.     
  247.     l++;
  248.   }
  249.   
  250.   return result;
  251. }
  253. int createRandomIndex(NDBT_Context* ctx, NDBT_Step* step){
  254.   const NdbDictionary::Table* pTab = ctx->getTab();
  255.   Ndb* pNdb = GETNDB(step);
  256.   bool logged = ctx->getProperty("LoggedIndexes", 1);
  258.   AttribList attrList;
  259.   attrList.buildAttribList(pTab);
  261.   int retries = 100;
  262.   while(retries > 0){
  263.     const Uint32 i = rand() % attrList.attriblist.size();
  264.     int res = create_index(ctx, i, pTab, pNdb, attrList.attriblist[i], 
  265.    logged);
  266.     if (res == SKIP_INDEX){
  267.       retries--;
  268.       continue;
  269.     }
  271.     if (res == NDBT_FAILED){
  272.       return NDBT_FAILED;
  273.     }
  274.     
  275.     ctx->setProperty("createRandomIndex", i);
  276.     // Now drop all indexes that where created
  277.     
  278.     return NDBT_OK;
  279.   }
  280.   
  281.   return NDBT_FAILED;
  282. }
  284. int createRandomIndex_Drop(NDBT_Context* ctx, NDBT_Step* step){
  285.   Ndb* pNdb = GETNDB(step);
  287.   Uint32 i = ctx->getProperty("createRandomIndex");
  288.   
  289.   BaseString::snprintf(idxName, 255, "IDC%d", i);
  290.   
  291.   // Drop index
  292.   ndbout << "Dropping index " << idxName << " ";
  293.   if (pNdb->getDictionary()->dropIndex(idxName, 
  294.        ctx->getTab()->getName()) != 0){
  295.     ndbout << "FAILED!" << endl;
  296.     ERR(pNdb->getDictionary()->getNdbError());
  297.     return NDBT_FAILED;
  298.   } else {
  299.     ndbout << "OK!" << endl;
  300.   }
  301.   
  302.   return NDBT_OK;
  303. }
  305. int createPkIndex(NDBT_Context* ctx, NDBT_Step* step){
  306.   bool orderedIndex = ctx->getProperty("OrderedIndex", (unsigned)0);
  308.   const NdbDictionary::Table* pTab = ctx->getTab();
  309.   Ndb* pNdb = GETNDB(step);
  311.   bool logged = ctx->getProperty("LoggedIndexes", 1);
  313.   // Create index    
  314.   BaseString::snprintf(pkIdxName, 255, "IDC_PK_%s", pTab->getName());
  315.   if (orderedIndex)
  316.     ndbout << "Creating " << ((logged)?"logged ": "temporary ") << "ordered index "
  317.    << pkIdxName << " (";
  318.   else
  319.     ndbout << "Creating " << ((logged)?"logged ": "temporary ") << "unique index "
  320.    << pkIdxName << " (";
  322.   NdbDictionary::Index pIdx(pkIdxName);
  323.   pIdx.setTable(pTab->getName());
  324.   if (orderedIndex)
  325.     pIdx.setType(NdbDictionary::Index::OrderedIndex);
  326.   else
  327.     pIdx.setType(NdbDictionary::Index::UniqueHashIndex);
  328.   for (int c = 0; c< pTab->getNoOfColumns(); c++){
  329.     const NdbDictionary::Column * col = pTab->getColumn(c);
  330.     if(col->getPrimaryKey()){
  331.       pIdx.addIndexColumn(col->getName());
  332.       ndbout << col->getName() <<" ";
  333.     }
  334.   }
  335.   
  336.   pIdx.setStoredIndex(logged);
  337.   ndbout << ") ";
  338.   if (pNdb->getDictionary()->createIndex(pIdx) != 0){
  339.     ndbout << "FAILED!" << endl;
  340.     const NdbError err = pNdb->getDictionary()->getNdbError();
  341.     ERR(err);
  342.     return NDBT_FAILED;
  343.   }
  345.   ndbout << "OK!" << endl;
  346.   return NDBT_OK;
  347. }
  349. int createPkIndex_Drop(NDBT_Context* ctx, NDBT_Step* step){
  350.   const NdbDictionary::Table* pTab = ctx->getTab();
  351.   Ndb* pNdb = GETNDB(step);
  353.   // Drop index
  354.   ndbout << "Dropping index " << pkIdxName << " ";
  355.   if (pNdb->getDictionary()->dropIndex(pkIdxName, 
  356.        pTab->getName()) != 0){
  357.     ndbout << "FAILED!" << endl;
  358.     ERR(pNdb->getDictionary()->getNdbError());
  359.     return NDBT_FAILED;
  360.   } else {
  361.     ndbout << "OK!" << endl;
  362.   }
  363.   
  364.   return NDBT_OK;
  365. }
  367. int
  368. runVerifyIndex(NDBT_Context* ctx, NDBT_Step* step){
  369.   // Verify that data in index match 
  370.   // table data
  371.   Ndb* pNdb = GETNDB(step);
  372.   UtilTransactions utilTrans(*ctx->getTab());
  373.   const int batchSize = ctx->getProperty("BatchSize", 16);
  374.   const int parallelism = batchSize > 240 ? 240 : batchSize;
  376.   do {
  377.     if (utilTrans.verifyIndex(pNdb, idxName, parallelism, true) != 0){
  378.       g_err << "Inconsistent index" << endl;
  379.       return NDBT_FAILED;
  380.     }
  381.   } while(ctx->isTestStopped() == false);
  382.   return NDBT_OK;
  383. }
  385. int
  386. runTransactions1(NDBT_Context* ctx, NDBT_Step* step){
  387.   // Verify that data in index match 
  388.   // table data
  389.   Ndb* pNdb = GETNDB(step);
  390.   HugoTransactions hugoTrans(*ctx->getTab());
  391.   const int batchSize = ctx->getProperty("BatchSize", 50);
  393.   int rows = ctx->getNumRecords();
  394.   while (ctx->isTestStopped() == false) {
  395.     if (hugoTrans.pkUpdateRecords(pNdb, rows, batchSize) != 0){
  396.       g_err << "Updated table failed" << endl;
  397.       return NDBT_FAILED;
  398.     }    
  400.     ctx->sync_down("PauseThreads");
  401.     if(ctx->isTestStopped())
  402.       break;
  403.     
  404.     if (hugoTrans.scanUpdateRecords(pNdb, rows, batchSize) != 0){
  405.       g_err << "Updated table failed" << endl;
  406.       return NDBT_FAILED;
  407.     }    
  408.     
  409.     ctx->sync_down("PauseThreads");
  410.   }
  411.   return NDBT_OK;
  412. }
  414. int
  415. runTransactions2(NDBT_Context* ctx, NDBT_Step* step){
  416.   // Verify that data in index match 
  417.   // table data
  418.   Ndb* pNdb = GETNDB(step);
  419.   HugoTransactions hugoTrans(*ctx->getTab());
  420.   const int batchSize = ctx->getProperty("BatchSize", 50);
  422.   int rows = ctx->getNumRecords();
  423.   while (ctx->isTestStopped() == false) {
  424. #if 1
  425.     if (hugoTrans.indexReadRecords(pNdb, pkIdxName, rows, batchSize) != 0){
  426.       g_err << "Index read failed" << endl;
  427.       return NDBT_FAILED;
  428.     }
  429. #endif
  430.     ctx->sync_down("PauseThreads");
  431.     if(ctx->isTestStopped())
  432.       break;
  433. #if 1
  434.     if (hugoTrans.indexUpdateRecords(pNdb, pkIdxName, rows, batchSize) != 0){
  435.       g_err << "Index update failed" << endl;
  436.       return NDBT_FAILED;
  437.     }
  438. #endif
  439.     ctx->sync_down("PauseThreads");
  440.   }
  441.   return NDBT_OK;
  442. }
  444. int
  445. runTransactions3(NDBT_Context* ctx, NDBT_Step* step){
  446.   // Verify that data in index match 
  447.   // table data
  448.   Ndb* pNdb = GETNDB(step);
  449.   HugoTransactions hugoTrans(*ctx->getTab());
  450.   UtilTransactions utilTrans(*ctx->getTab());
  451.   const int batchSize = ctx->getProperty("BatchSize", 32);
  452.   const int parallel = batchSize > 240 ? 240 : batchSize;
  454.   int rows = ctx->getNumRecords();
  455.   while (ctx->isTestStopped() == false) {
  456.     if(hugoTrans.loadTable(pNdb, rows, batchSize, false) != 0){
  457.       g_err << "Load table failed" << endl;
  458.       return NDBT_FAILED;
  459.     }
  460.     ctx->sync_down("PauseThreads");
  461.     if(ctx->isTestStopped())
  462.       break;
  464.     if (hugoTrans.pkUpdateRecords(pNdb, rows, batchSize) != 0){
  465.       g_err << "Updated table failed" << endl;
  466.       return NDBT_FAILED;
  467.     }    
  469.     ctx->sync_down("PauseThreads");
  470.     if(ctx->isTestStopped())
  471.       break;
  472.     
  473.     if (hugoTrans.indexReadRecords(pNdb, pkIdxName, rows, batchSize) != 0){
  474.       g_err << "Index read failed" << endl;
  475.       return NDBT_FAILED;
  476.     }
  477.     
  478.     ctx->sync_down("PauseThreads");
  479.     if(ctx->isTestStopped())
  480.       break;
  481.     
  482.     if (hugoTrans.indexUpdateRecords(pNdb, pkIdxName, rows, batchSize) != 0){
  483.       g_err << "Index update failed" << endl;
  484.       return NDBT_FAILED;
  485.     }
  486.     
  487.     ctx->sync_down("PauseThreads");
  488.     if(ctx->isTestStopped())
  489.       break;
  491.     if (hugoTrans.scanUpdateRecords(pNdb, rows, 5, parallel) != 0){
  492.       g_err << "Scan updated table failed" << endl;
  493.       return NDBT_FAILED;
  494.     }
  496.     ctx->sync_down("PauseThreads");
  497.     if(ctx->isTestStopped())
  498.       break;
  500.     if(utilTrans.clearTable(pNdb, rows, parallel) != 0){
  501.       g_err << "Clear table failed" << endl;
  502.       return NDBT_FAILED;
  503.     }
  505.     ctx->sync_down("PauseThreads");
  506.     if(ctx->isTestStopped())
  507.       break;
  508.     
  509.     int count = -1;
  510.     if(utilTrans.selectCount(pNdb, 64, &count) != 0 || count != 0)
  511.       return NDBT_FAILED;
  512.     ctx->sync_down("PauseThreads");
  513.   }
  514.   return NDBT_OK;
  515. }
  517. int runRestarts(NDBT_Context* ctx, NDBT_Step* step){
  518.   int result = NDBT_OK;
  519.   int loops = ctx->getNumLoops();
  520.   NDBT_TestCase* pCase = ctx->getCase();
  521.   NdbRestarts restarts;
  522.   int i = 0;
  523.   int timeout = 240;
  524.   int sync_threads = ctx->getProperty("Threads", (unsigned)0);
  526.   while(i<loops && result != NDBT_FAILED && !ctx->isTestStopped()){
  527.     if(restarts.executeRestart("RestartRandomNodeAbort", timeout) != 0){
  528.       g_err << "Failed to executeRestart(" <<pCase->getName() <<")" << endl;
  529.       result = NDBT_FAILED;
  530.       break;
  531.     }    
  532.     ctx->sync_up_and_wait("PauseThreads", sync_threads);
  533.     i++;
  534.   }
  535.   ctx->stopTest();
  536.   return result;
  537. }
  539. int runCreateLoadDropIndex(NDBT_Context* ctx, NDBT_Step* step){
  540.   int loops = ctx->getNumLoops();
  541.   int records = ctx->getNumRecords();
  542.   int l = 0;
  543.   const NdbDictionary::Table* pTab = ctx->getTab();
  544.   Ndb* pNdb = GETNDB(step);
  545.   int result = NDBT_OK;
  546.   int batchSize = ctx->getProperty("BatchSize", 1);
  547.   int parallelism = batchSize > 240? 240: batchSize;
  548.   ndbout << "batchSize="<<batchSize<<endl;
  549.   bool logged = ctx->getProperty("LoggedIndexes", 1);
  551.   HugoTransactions hugoTrans(*pTab);
  552.   UtilTransactions utilTrans(*pTab);
  553.   AttribList attrList;
  554.   attrList.buildAttribList(pTab);
  556.   for (unsigned int i = 0; i < attrList.attriblist.size(); i++){
  557.         
  558.     while (l < loops && result == NDBT_OK){
  560.       if ((l % 2) == 0){
  561. // Create index first and then load
  563. // Try to create index
  564. if (create_index(ctx, i, pTab, pNdb, attrList.attriblist[i], logged) == NDBT_FAILED){
  565.   result = NDBT_FAILED;      
  566. }
  568. // Load the table with data
  569. ndbout << "Loading data after" << endl;
  570. CHECK(hugoTrans.loadTable(pNdb, records, batchSize) == 0);
  573.       } else {
  574. // Load table then create index
  576. // Load the table with data
  577. ndbout << "Loading data before" << endl;
  578. CHECK(hugoTrans.loadTable(pNdb, records, batchSize) == 0);
  580. // Try to create index
  581. if (create_index(ctx, i, pTab, pNdb, attrList.attriblist[i], logged) == NDBT_FAILED)
  582.   result = NDBT_FAILED;      
  584.       }
  585.       
  586.       // Verify that data in index match 
  587.       // table data
  588.       CHECK(utilTrans.verifyIndex(pNdb, idxName, parallelism) == 0);
  589.       
  590.       // Do it all...
  591.       ndbout <<"Doing it all"<<endl;
  592.       int count;
  593.       ndbout << "  pkUpdateRecords" << endl;
  594.       CHECK(hugoTrans.pkUpdateRecords(pNdb, records, batchSize) == 0);
  595.       CHECK(utilTrans.verifyIndex(pNdb, idxName, parallelism) == 0);
  596.       CHECK(hugoTrans.pkUpdateRecords(pNdb, records, batchSize) == 0);
  597.       CHECK(utilTrans.verifyIndex(pNdb, idxName, parallelism) == 0);
  598.       ndbout << "  pkDelRecords half" << endl;
  599.       CHECK(hugoTrans.pkDelRecords(pNdb, records/2, batchSize) == 0);
  600.       CHECK(utilTrans.verifyIndex(pNdb, idxName, parallelism) == 0);
  601.       ndbout << "  scanUpdateRecords" << endl;
  602.       CHECK(hugoTrans.scanUpdateRecords(pNdb, records/2, parallelism) == 0);
  603.       CHECK(utilTrans.verifyIndex(pNdb, idxName, parallelism) == 0);
  604.       ndbout << "  clearTable" << endl;
  605.       CHECK(utilTrans.clearTable(pNdb, records/2, parallelism) == 0);
  606.       CHECK(utilTrans.verifyIndex(pNdb, idxName, parallelism) == 0);
  607.       CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  608.       CHECK(count == 0);
  609.       ndbout << "  loadTable" << endl;
  610.       CHECK(hugoTrans.loadTable(pNdb, records, batchSize) == 0);
  611.       CHECK(utilTrans.verifyIndex(pNdb, idxName, parallelism) == 0);
  612.       ndbout << "  loadTable again" << endl;
  613.       CHECK(hugoTrans.loadTable(pNdb, records, batchSize) == 0);
  614.       CHECK(utilTrans.verifyIndex(pNdb, idxName, parallelism) == 0);
  615.       CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  616.       CHECK(count == records);
  619.       if ((l % 2) == 0){
  620. // Drop index first and then clear
  622. // Try to create index
  623. if (drop_index(i, pNdb, pTab, attrList.attriblist[i]) != NDBT_OK){
  624.   result = NDBT_FAILED;      
  625. }
  627. // Clear table
  628. ndbout << "Clearing table after" << endl;
  629. CHECK(hugoTrans.clearTable(pNdb, records, parallelism) == 0);
  632.       } else {
  633. // Clear table then drop index
  635. //Clear table
  636. ndbout << "Clearing table before" << endl;
  637. CHECK(hugoTrans.clearTable(pNdb, records, parallelism) == 0);
  639. // Try to drop index
  640. if (drop_index(i, pNdb, pTab, attrList.attriblist[i]) != NDBT_OK)
  641.   result = NDBT_FAILED;      
  642.       }
  643.       
  644.       ndbout << "  Done!" << endl;
  645.       l++;
  646.     }
  647.       
  648.     // Make sure index is dropped
  649.     drop_index(i, pNdb, pTab, attrList.attriblist[i]);
  651.   }
  653.   return result;
  654. }
  656. int runInsertDelete(NDBT_Context* ctx, NDBT_Step* step){
  657.   int loops = ctx->getNumLoops();
  658.   int records = ctx->getNumRecords();
  659.   const NdbDictionary::Table* pTab = ctx->getTab();
  660.   Ndb* pNdb = GETNDB(step);
  661.   int result = NDBT_OK;
  662.   int batchSize = ctx->getProperty("BatchSize", 1);
  663.   int parallelism = batchSize > 240? 240: batchSize;
  664.   ndbout << "batchSize="<<batchSize<<endl;
  665.   bool logged = ctx->getProperty("LoggedIndexes", 1);
  667.   HugoTransactions hugoTrans(*pTab);
  668.   UtilTransactions utilTrans(*pTab);  
  670.   AttribList attrList;
  671.   attrList.buildAttribList(pTab);
  673.   for (unsigned int i = 0; i < attrList.attriblist.size(); i++){
  674.     
  675.     Attrib* attr = attrList.attriblist[i]; 
  676.     // Create index
  677.     if (create_index(ctx, i, pTab, pNdb, attr, logged) == NDBT_OK){
  678.       int l = 1;
  679.       while (l <= loops && result == NDBT_OK){
  680.   
  681. CHECK(hugoTrans.loadTable(pNdb, records, batchSize) == 0);
  682. CHECK(utilTrans.verifyIndex(pNdb, idxName, parallelism) == 0);
  683. CHECK(utilTrans.clearTable(pNdb, records, parallelism) == 0);
  684. CHECK(utilTrans.verifyIndex(pNdb, idxName, parallelism) == 0);
  685. l++;     
  686.       }            
  687.       
  688.       // Drop index
  689.       if (drop_index(i, pNdb, pTab, attr) != NDBT_OK)
  690. result = NDBT_FAILED;            
  691.     }    
  692.   }
  693.   
  694.   return result;
  695. }
  696. int runLoadTable(NDBT_Context* ctx, NDBT_Step* step){
  697.   int records = ctx->getNumRecords();
  698.   
  699.   HugoTransactions hugoTrans(*ctx->getTab());
  700.   int batchSize = ctx->getProperty("BatchSize", 1);
  701.   if(hugoTrans.loadTable(GETNDB(step), records, batchSize) != 0){
  702.     return NDBT_FAILED;
  703.   }
  704.   return NDBT_OK;
  705. }
  708. int runClearTable(NDBT_Context* ctx, NDBT_Step* step){
  709.   int records = ctx->getNumRecords();
  710.   
  711.   UtilTransactions utilTrans(*ctx->getTab());
  712.   if (utilTrans.clearTable(GETNDB(step),  records) != 0){
  713.     return NDBT_FAILED;
  714.   }
  715.   return NDBT_OK;
  716. }
  718. int runSystemRestart1(NDBT_Context* ctx, NDBT_Step* step){
  719.   Ndb* pNdb = GETNDB(step);
  720.   int result = NDBT_OK;
  721.   int timeout = 300;
  722.   Uint32 loops = ctx->getNumLoops();
  723.   int records = ctx->getNumRecords();
  724.   int count;
  725.   NdbRestarter restarter;
  726.   Uint32 i = 1;
  728.   UtilTransactions utilTrans(*ctx->getTab());
  729.   HugoTransactions hugoTrans(*ctx->getTab());
  730.   const char * name = ctx->getTab()->getName();
  731.   while(i<=loops && result != NDBT_FAILED){
  733.     ndbout << "Loop " << i << "/"<< loops <<" started" << endl;
  734.     /*
  735.       1. Load data
  736.       2. Restart cluster and verify records
  737.       3. Update records
  738.       4. Restart cluster and verify records
  739.       5. Delete half of the records
  740.       6. Restart cluster and verify records
  741.       7. Delete all records
  742.       8. Restart cluster and verify records
  743.       9. Insert, update, delete records
  744.       10. Restart cluster and verify records
  745.       11. Insert, update, delete records
  746.       12. Restart cluster with error insert 5020 and verify records
  747.     */
  748.     ndbout << "Loading records..." << endl;
  749.     CHECK(hugoTrans.loadTable(pNdb, records, 1) == 0);
  750.     CHECK(utilTrans.verifyIndex(pNdb, idxName, 16, false) == 0);
  751.     
  752.     ndbout << "Restarting cluster" << endl;
  753.     CHECK(restarter.restartAll() == 0);
  754.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  755.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  757.     ndbout << "Verifying records..." << endl;
  758.     CHECK(hugoTrans.pkReadRecords(pNdb, records) == 0);
  759.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  760.     CHECK(count == records);
  761.     CHECK(utilTrans.verifyIndex(pNdb, idxName, 16, false) == 0);
  763.     ndbout << "Updating records..." << endl;
  764.     CHECK(hugoTrans.pkUpdateRecords(pNdb, records) == 0);
  765.     CHECK(utilTrans.verifyIndex(pNdb, idxName, 16, false) == 0);
  767.     ndbout << "Restarting cluster..." << endl;
  768.     CHECK(restarter.restartAll() == 0);
  769.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  770.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  772.     ndbout << "Verifying records..." << endl;
  773.     CHECK(hugoTrans.pkReadRecords(pNdb, records) == 0);
  774.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  775.     CHECK(count == records);
  776.     CHECK(utilTrans.verifyIndex(pNdb, idxName, 16, false) == 0);
  777.     
  778.     ndbout << "Deleting 50% of records..." << endl;
  779.     CHECK(hugoTrans.pkDelRecords(pNdb, records/2) == 0);
  780.     CHECK(utilTrans.verifyIndex(pNdb, idxName, 16, false) == 0);
  782.     ndbout << "Restarting cluster..." << endl;
  783.     CHECK(restarter.restartAll() == 0);
  784.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  785.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  787.     ndbout << "Verifying records..." << endl;
  788.     CHECK(hugoTrans.scanReadRecords(pNdb, records/2, 0, 64) == 0);
  789.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  790.     CHECK(count == (records/2));
  791.     CHECK(utilTrans.verifyIndex(pNdb, idxName, 16, false) == 0);
  793.     ndbout << "Deleting all records..." << endl;
  794.     CHECK(utilTrans.clearTable(pNdb, records/2) == 0);
  795.     CHECK(utilTrans.verifyIndex(pNdb, idxName, 16, false) == 0);
  797.     ndbout << "Restarting cluster..." << endl;
  798.     CHECK(restarter.restartAll() == 0);
  799.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  800.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  802.     ndbout << "Verifying records..." << endl;
  803.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  804.     CHECK(count == 0);
  805.     CHECK(utilTrans.verifyIndex(pNdb, idxName, 16, false) == 0);
  807.     ndbout << "Doing it all..." << endl;
  808.     CHECK(hugoTrans.loadTable(pNdb, records, 1) == 0);
  809.     CHECK(utilTrans.verifyIndex(pNdb, idxName, 16, false) == 0);
  810.     CHECK(hugoTrans.pkUpdateRecords(pNdb, records) == 0);
  811.     CHECK(utilTrans.verifyIndex(pNdb, idxName, 16, false) == 0);
  812.     CHECK(hugoTrans.pkDelRecords(pNdb, records/2) == 0);
  813.     CHECK(hugoTrans.scanUpdateRecords(pNdb, records) == 0);
  814.     CHECK(utilTrans.verifyIndex(pNdb, idxName, 16, false) == 0);
  815.     CHECK(utilTrans.clearTable(pNdb, records) == 0);
  816.     CHECK(hugoTrans.loadTable(pNdb, records, 1) == 0);
  817.     CHECK(utilTrans.clearTable(pNdb, records) == 0);
  818.     CHECK(hugoTrans.loadTable(pNdb, records, 1) == 0);
  819.     CHECK(hugoTrans.pkUpdateRecords(pNdb, records) == 0);
  820.     CHECK(utilTrans.clearTable(pNdb, records) == 0);
  822.     ndbout << "Restarting cluster..." << endl;
  823.     CHECK(restarter.restartAll() == 0);
  824.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  825.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  827.     ndbout << "Verifying records..." << endl;
  828.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  829.     CHECK(count == 0);
  831.     ndbout << "Doing it all..." << endl;
  832.     CHECK(hugoTrans.loadTable(pNdb, records, 1) == 0);
  833.     CHECK(utilTrans.verifyIndex(pNdb, idxName,  16, false) == 0);
  834.     CHECK(hugoTrans.pkUpdateRecords(pNdb, records) == 0);
  835.     CHECK(utilTrans.verifyIndex(pNdb, idxName,  16, false) == 0);
  836.     CHECK(hugoTrans.pkDelRecords(pNdb, records/2) == 0);
  837.     CHECK(utilTrans.verifyIndex(pNdb, idxName,  16, false) == 0);
  838.     CHECK(hugoTrans.scanUpdateRecords(pNdb, records) == 0);
  839.     CHECK(utilTrans.verifyIndex(pNdb, idxName,  16, false) == 0);
  840.     CHECK(utilTrans.clearTable(pNdb, records) == 0);
  841.     CHECK(hugoTrans.loadTable(pNdb, records, 1) == 0);
  842.     CHECK(utilTrans.clearTable(pNdb, records) == 0);
  844.     ndbout << "Restarting cluster with error insert 5020..." << endl;
  845.     CHECK(restarter.restartAll(false, true) == 0);
  846.     CHECK(restarter.waitClusterNoStart(timeout) == 0);
  847.     CHECK(restarter.insertErrorInAllNodes(5020) == 0);
  848.     CHECK(restarter.startAll() == 0);
  849.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  850.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  851.     
  852.     i++;
  853.   }
  855.   ctx->stopTest();
  856.   ndbout << "runSystemRestart1 finished" << endl;  
  858.   return result;
  859. }
  861. #define CHECK2(b, t) if(!b){ g_err << __LINE__ << ": " << t << endl; break;}
  863. int
  864. runMixed1(NDBT_Context* ctx, NDBT_Step* step){
  865.   // Verify that data in index match 
  866.   // table data
  867.   Ndb* pNdb = GETNDB(step);
  868.   HugoOperations hugoOps(*ctx->getTab());
  871.   do {
  872.     // TC1
  873.     g_err << "pkRead, indexRead, Commit" << endl;
  874.     CHECK2(hugoOps.startTransaction(pNdb) == 0, "startTransaction");
  875.     CHECK2(hugoOps.indexReadRecords(pNdb, pkIdxName, 0) == 0, "indexReadRecords");
  876.     CHECK2(hugoOps.pkReadRecord(pNdb, 0) == 0, "pkReadRecord");
  877.     CHECK2(hugoOps.execute_Commit(pNdb) == 0, "executeCommit");
  878.     CHECK2(hugoOps.closeTransaction(pNdb) == 0, "closeTransaction");
  880.     // TC1
  881.     g_err << "pkRead, indexRead, Commit" << endl;
  882.     CHECK2(hugoOps.startTransaction(pNdb) == 0, "startTransaction");
  883.     CHECK2(hugoOps.pkReadRecord(pNdb, 0) == 0, "pkReadRecord");
  884.     CHECK2(hugoOps.indexReadRecords(pNdb, pkIdxName, 0) == 0, "indexReadRecords");
  885.     CHECK2(hugoOps.execute_Commit(pNdb) == 0, "executeCommit");
  886.     CHECK2(hugoOps.closeTransaction(pNdb) == 0, "closeTransaction");
  887.     
  889.     // TC2
  890.     g_err << "pkRead, indexRead, NoCommit, Commit" << endl;
  891.     CHECK2(hugoOps.startTransaction(pNdb) == 0, "startTransaction");
  892.     CHECK2(hugoOps.pkReadRecord(pNdb, 0) == 0, "pkReadRecord");
  893.     CHECK2(hugoOps.indexReadRecords(pNdb, pkIdxName, 0) == 0,
  894.    "indexReadRecords");
  895.     CHECK2(hugoOps.execute_NoCommit(pNdb) == 0, "executeNoCommit");
  896.     CHECK2(hugoOps.execute_Commit(pNdb) == 0, "executeCommit");
  897.     CHECK2(hugoOps.closeTransaction(pNdb) == 0, "closeTransaction");
  899.     // TC3
  900.     g_err << "pkRead, pkRead, Commit" << endl;
  901.     CHECK2(hugoOps.startTransaction(pNdb) == 0, "startTransaction ");
  902.     CHECK2(hugoOps.pkReadRecord(pNdb, 0) == 0, "pkReadRecords ");
  903.     CHECK2(hugoOps.pkReadRecord(pNdb, 0) == 0, "pkReadRecords ");
  904.     CHECK2(hugoOps.execute_Commit(pNdb) == 0, "executeCommit");
  905.     CHECK2(hugoOps.closeTransaction(pNdb) == 0, "closeTransaction ");
  907.     // TC4
  908.     g_err << "indexRead, indexRead, Commit" << endl;
  910.     CHECK2(hugoOps.startTransaction(pNdb) == 0, "startTransaction ");
  911.     CHECK2(hugoOps.indexReadRecords(pNdb, pkIdxName, 0) == 0, "indexReadRecords");
  912.     CHECK2(hugoOps.indexReadRecords(pNdb, pkIdxName, 0) == 0, "indexReadRecords");
  913.     CHECK2(hugoOps.execute_Commit(pNdb) == 0, "executeCommit");
  915.     CHECK2(hugoOps.closeTransaction(pNdb) == 0, "closeTransaction ");
  917.     return NDBT_OK;
  918.   } while(false);
  921.   hugoOps.closeTransaction(pNdb);
  922.   return NDBT_FAILED;
  923. }
  925. int
  926. runBuildDuring(NDBT_Context* ctx, NDBT_Step* step){
  927.   // Verify that data in index match 
  928.   // table data
  929.   const int Threads = ctx->getProperty("Threads", (Uint32)0);
  930.   const int loops = ctx->getNumLoops();
  932.   for(int i = 0; i<loops; i++){
  933. #if 1
  934.     if(createPkIndex(ctx, step) != NDBT_OK){
  935.       g_err << "Failed to create index" << endl;
  936.       return NDBT_FAILED;
  937.     }
  938. #endif
  940.     if(ctx->isTestStopped())
  941.       break;
  943. #if 1
  944.     if(createRandomIndex(ctx, step) != NDBT_OK){
  945.       g_err << "Failed to create index" << endl;
  946.       return NDBT_FAILED;
  947.     }
  948. #endif
  950.     if(ctx->isTestStopped())
  951.       break;
  953.     ctx->setProperty("pause", 1);
  954.     int count = 0;
  955.     for(int j = 0; count < Threads && !ctx->isTestStopped(); 
  956. j = (j+1) % Threads){
  957.       char buf[255];
  958.       sprintf(buf, "Thread%d_paused", j);
  959.       int tmp = ctx->getProperty(buf, (Uint32)0);
  960.       count += tmp;
  961.     }
  962.     
  963.     if(ctx->isTestStopped())
  964.       break;
  966. #if 1
  967.     if(createPkIndex_Drop(ctx, step) != NDBT_OK){
  968.       g_err << "Failed to drop index" << endl;
  969.       return NDBT_FAILED;
  970.     }
  971. #endif
  973.     if(ctx->isTestStopped())
  974.       break;
  975.     
  976. #if 1
  977.     if(createRandomIndex_Drop(ctx, step) != NDBT_OK){
  978.       g_err << "Failed to drop index" << endl;
  979.       return NDBT_FAILED;
  980.     }
  981. #endif
  983.     ctx->setProperty("pause", (Uint32)0);
  984.     NdbSleep_SecSleep(2);
  985.   }
  987.   ctx->stopTest();
  988.   return NDBT_OK;
  989. }
  991. static NdbLockable g_lock;
  992. static int threadCounter = 0;
  994. void
  995. wait_paused(NDBT_Context* ctx, int id){
  996.   if(ctx->getProperty("pause", (Uint32)0) == 1){
  997.     char buf[255];
  998.     sprintf(buf, "Thread%d_paused", id);
  999.     ctx->setProperty(buf, 1);
  1000.     while(!ctx->isTestStopped() && ctx->getProperty("pause", (Uint32)0) == 1){
  1001.       NdbSleep_MilliSleep(250);
  1002.     }
  1003.     ctx->setProperty(buf, (Uint32)0);
  1004.   }
  1005. }
  1007. int
  1008. runTransactions4(NDBT_Context* ctx, NDBT_Step* step){
  1010.   g_lock.lock();
  1011.   const int ThreadId = threadCounter++;
  1012.   g_lock.unlock();
  1013.   
  1014.   // Verify that data in index match 
  1015.   // table data
  1016.   Ndb* pNdb = GETNDB(step);
  1017.   HugoTransactions hugoTrans(*ctx->getTab());
  1018.   UtilTransactions utilTrans(*ctx->getTab());
  1019.   const int batchSize = ctx->getProperty("BatchSize", 32);
  1020.   const int parallel = batchSize > 240 ? 240 : batchSize;
  1022.   int rows = ctx->getNumRecords();
  1023.   while (ctx->isTestStopped() == false) {
  1024.     if(hugoTrans.loadTable(pNdb, rows, batchSize, false) != 0){
  1025.       g_err << "Load table failed" << endl;
  1026.       return NDBT_FAILED;
  1027.     }
  1029.     wait_paused(ctx, ThreadId);
  1031.     if(ctx->isTestStopped())
  1032.       break;
  1034.     if (hugoTrans.pkUpdateRecords(pNdb, rows, batchSize) != 0){
  1035.       g_err << "Updated table failed" << endl;
  1036.       return NDBT_FAILED;
  1037.     }    
  1039.     wait_paused(ctx, ThreadId);
  1040.     
  1041.     if(ctx->isTestStopped())
  1042.       break;
  1043.     
  1044.     if (hugoTrans.scanUpdateRecords(pNdb, rows, 5, parallel) != 0){
  1045.       g_err << "Scan updated table failed" << endl;
  1046.       return NDBT_FAILED;
  1047.     }
  1049.     wait_paused(ctx, ThreadId);
  1051.     if(ctx->isTestStopped())
  1052.       break;
  1054.     if(utilTrans.clearTable(pNdb, rows, parallel) != 0){
  1055.       g_err << "Clear table failed" << endl;
  1056.       return NDBT_FAILED;
  1057.     }
  1058.   }
  1059.   return NDBT_OK;
  1060. }
  1062. int
  1063. runUniqueNullTransactions(NDBT_Context* ctx, NDBT_Step* step){
  1064.   Ndb* pNdb = GETNDB(step);
  1066.   bool logged = ctx->getProperty("LoggedIndexes", 1);
  1067.   bool orderedIndex = ctx->getProperty("OrderedIndex", (unsigned)0);
  1068.   NdbConnection * pTrans = 0;
  1070.   const NdbDictionary::Table* pTab = ctx->getTab();
  1071.   // Create index    
  1072.   char nullIndex[255];
  1073.   BaseString::snprintf(nullIndex, 255, "IDC_PK_%s_NULL", pTab->getName());
  1074.   if (orderedIndex)
  1075.     ndbout << "Creating " << ((logged)?"logged ": "temporary ") << "ordered index "
  1076.    << pkIdxName << " (";
  1077.   else
  1078.     ndbout << "Creating " << ((logged)?"logged ": "temporary ") << "unique index "
  1079.    << pkIdxName << " (";
  1081.   NdbDictionary::Index pIdx(pkIdxName);
  1082.   pIdx.setTable(pTab->getName());
  1083.   if (orderedIndex)
  1084.     pIdx.setType(NdbDictionary::Index::OrderedIndex);
  1085.   else
  1086.     pIdx.setType(NdbDictionary::Index::UniqueHashIndex);
  1087.   pIdx.setStoredIndex(logged);
  1088.   int c;
  1089.   for (c = 0; c< pTab->getNoOfColumns(); c++){
  1090.     const NdbDictionary::Column * col = pTab->getColumn(c);
  1091.     if(col->getPrimaryKey()){
  1092.       pIdx.addIndexColumn(col->getName());
  1093.       ndbout << col->getName() <<" ";
  1094.     }
  1095.   }
  1096.   
  1097.   int colId = -1;
  1098.   for (c = 0; c< pTab->getNoOfColumns(); c++){
  1099.     const NdbDictionary::Column * col = pTab->getColumn(c);
  1100.     if(col->getNullable()){
  1101.       pIdx.addIndexColumn(col->getName());
  1102.       ndbout << col->getName() <<" ";
  1103.       colId = c;
  1104.       break;
  1105.     }
  1106.   }
  1107.   ndbout << ") ";
  1109.   if(colId == -1){
  1110.     ndbout << endl << "No nullable column found -> NDBT_FAILED" << endl; 
  1111.     return NDBT_FAILED;
  1112.   }
  1113.   
  1114.   if (pNdb->getDictionary()->createIndex(pIdx) != 0){
  1115.     ndbout << "FAILED!" << endl;
  1116.     const NdbError err = pNdb->getDictionary()->getNdbError();
  1117.     ERR(err);
  1118.     return NDBT_FAILED;
  1119.   }
  1120.   
  1121.   int result = NDBT_OK;
  1123.   HugoTransactions hugoTrans(*ctx->getTab());
  1124.   const int batchSize = ctx->getProperty("BatchSize", 50);
  1125.   int loops = ctx->getNumLoops();
  1126.   int rows = ctx->getNumRecords();
  1127.   while (loops-- > 0 && ctx->isTestStopped() == false) {
  1128.     if (hugoTrans.pkUpdateRecords(pNdb, rows, batchSize) != 0){
  1129.       g_err << "Updated table failed" << endl;
  1130.       result = NDBT_FAILED;
  1131.       goto done;
  1132.     }    
  1133.   }
  1135.   if(ctx->isTestStopped()){
  1136.     goto done;
  1137.   }
  1139.   ctx->stopTest();
  1140.   while(ctx->getNoOfRunningSteps() > 1){
  1141.     NdbSleep_MilliSleep(100);
  1142.   }
  1144.   result = NDBT_FAILED;
  1145.   pTrans = pNdb->startTransaction();
  1146.   NdbScanOperation * sOp;
  1147.   NdbOperation * uOp;
  1148.   NdbResultSet * rs;
  1149.   int eof;
  1150.   if(!pTrans) goto done;
  1151.   sOp = pTrans->getNdbScanOperation(pTab->getName());
  1152.   if(!sOp) goto done;
  1153.   rs = sOp->readTuples(NdbScanOperation::LM_Exclusive);
  1154.   if(!rs) goto done;
  1155.   if(pTrans->execute(NoCommit) == -1) goto done;
  1156.   while((eof = rs->nextResult(true)) == 0){
  1157.     do {
  1158.       NdbOperation * uOp = rs->updateTuple();
  1159.       if(uOp == 0) goto done;
  1160.       uOp->setValue(colId, 0);
  1161.     } while((eof = rs->nextResult(false)) == 0);
  1162.     eof = pTrans->execute(Commit);
  1163.     if(eof == -1) goto done;
  1164.   }
  1165.   
  1166.  done:
  1167.   if(pTrans) pNdb->closeTransaction(pTrans);
  1168.   pNdb->getDictionary()->dropIndex(nullIndex, pTab->getName());
  1169.   return result;
  1170. }
  1172. int runLQHKEYREF(NDBT_Context* ctx, NDBT_Step* step){
  1173.   int result = NDBT_OK;
  1174.   int loops = ctx->getNumLoops() * 100;
  1175.   NdbRestarter restarter;
  1176.   
  1177.   myRandom48Init(NdbTick_CurrentMillisecond());
  1179. #if 0
  1180.   int val = DumpStateOrd::DihMinTimeBetweenLCP;
  1181.   if(restarter.dumpStateAllNodes(&val, 1) != 0){
  1182.     g_err << "Failed to dump DihMinTimeBetweenLCP" << endl;
  1183.     return NDBT_FAILED;
  1184.   }
  1185. #endif
  1187.   for(int i = 0; i<loops && !ctx->isTestStopped(); i++){
  1188.     int randomId = myRandom48(restarter.getNumDbNodes());
  1189.     int nodeId = restarter.getDbNodeId(randomId);
  1191.     const Uint32 error = 5031 + (i % 3);
  1192.     
  1193.     if(restarter.insertErrorInNode(nodeId, error) != 0){
  1194.       g_err << "Failed to error insert( " << error << ") in node "
  1195.     << nodeId << endl;
  1196.       return NDBT_FAILED;
  1197.     }
  1198.   }
  1199.   
  1200.   ctx->stopTest();
  1201.   return NDBT_OK;
  1202. }
  1204. NDBT_TESTSUITE(testIndex);
  1205. TESTCASE("CreateAll", 
  1206.  "Test that we can create all various indexes on each tablen"
  1207.  "Then drop the indexesn"){
  1208.   INITIALIZER(runCreateIndexes);
  1209. }
  1210. TESTCASE("CreateAll_O",
  1211.  "Test that we can create all various indexes on each tablen"
  1212.  "Then drop the indexesn"){
  1213.   TC_PROPERTY("OrderedIndex", 1);
  1214.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1215.   INITIALIZER(runCreateIndexes);
  1216. }
  1217. TESTCASE("InsertDeleteGentle", 
  1218.  "Create one index, then perform insert and delete in the tablen"
  1219.  "loop number of times. Use batch size 1."){
  1220.   TC_PROPERTY("BatchSize", 1);
  1221.   INITIALIZER(runInsertDelete);
  1222.   FINALIZER(runClearTable);
  1223. }
  1224. TESTCASE("InsertDeleteGentle_O",
  1225.  "Create one index, then perform insert and delete in the tablen"
  1226.  "loop number of times. Use batch size 1."){
  1227.   TC_PROPERTY("OrderedIndex", 1);
  1228.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1229.   TC_PROPERTY("BatchSize", 1);
  1230.   INITIALIZER(runInsertDelete);
  1231.   FINALIZER(runClearTable);
  1232. }
  1233. TESTCASE("InsertDelete", 
  1234.  "Create one index, then perform insert and delete in the tablen"
  1235.  "loop number of times. Use batchsize 512 to stress db more"){
  1236.   TC_PROPERTY("BatchSize", 512);
  1237.   INITIALIZER(runInsertDelete);
  1238.   FINALIZER(runClearTable);
  1240. }
  1241. TESTCASE("InsertDelete_O", 
  1242.  "Create one index, then perform insert and delete in the tablen"
  1243.  "loop number of times. Use batchsize 512 to stress db more"){
  1244.   TC_PROPERTY("OrderedIndex", 1);
  1245.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1246.   TC_PROPERTY("BatchSize", 512);
  1247.   INITIALIZER(runInsertDelete);
  1248.   FINALIZER(runClearTable);
  1250. }
  1251. TESTCASE("CreateLoadDropGentle", 
  1252.  "Try to create, drop and load various indexes n"
  1253.  "on table loop number of times.Usa batch size 1.n"){
  1254.   TC_PROPERTY("BatchSize", 1);
  1255.   INITIALIZER(runCreateLoadDropIndex);
  1256. }
  1257. TESTCASE("CreateLoadDropGentle_O", 
  1258.  "Try to create, drop and load various indexes n"
  1259.  "on table loop number of times.Usa batch size 1.n"){
  1260.   TC_PROPERTY("OrderedIndex", 1);
  1261.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1262.   TC_PROPERTY("BatchSize", 1);
  1263.   INITIALIZER(runCreateLoadDropIndex);
  1264. }
  1265. TESTCASE("CreateLoadDrop", 
  1266.  "Try to create, drop and load various indexes n"
  1267.  "on table loop number of times. Use batchsize 512 to stress db moren"){
  1268.   TC_PROPERTY("BatchSize", 512);
  1269.   INITIALIZER(runCreateLoadDropIndex);
  1270. }
  1271. TESTCASE("CreateLoadDrop_O", 
  1272.  "Try to create, drop and load various indexes n"
  1273.  "on table loop number of times. Use batchsize 512 to stress db moren"){
  1274.   TC_PROPERTY("OrderedIndex", 1);
  1275.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1276.   TC_PROPERTY("BatchSize", 512);
  1277.   INITIALIZER(runCreateLoadDropIndex);
  1278. }
  1279. TESTCASE("NFNR1", 
  1280.  "Test that indexes are correctly maintained during node fail and node restart"){ 
  1281.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1282.   //TC_PROPERTY("Threads", 2);
  1283.   INITIALIZER(runClearTable);
  1284.   INITIALIZER(createRandomIndex);
  1285.   INITIALIZER(runLoadTable);
  1286.   STEP(runRestarts);
  1287.   STEP(runTransactions1);
  1288.   STEP(runTransactions1);
  1289.   FINALIZER(runVerifyIndex);
  1290.   FINALIZER(createRandomIndex_Drop);
  1291.   FINALIZER(runClearTable);
  1292. }
  1293. TESTCASE("NFNR1_O", 
  1294.  "Test that indexes are correctly maintained during node fail and node restart"){ 
  1295.   TC_PROPERTY("OrderedIndex", 1);
  1296.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1297.   INITIALIZER(runClearTable);
  1298.   INITIALIZER(createRandomIndex);
  1299.   INITIALIZER(runLoadTable);
  1300.   STEP(runRestarts);
  1301.   STEP(runTransactions1);
  1302.   STEP(runTransactions1);
  1303.   FINALIZER(runVerifyIndex);
  1304.   FINALIZER(createRandomIndex_Drop);
  1305.   FINALIZER(runClearTable);
  1306. }
  1307. TESTCASE("NFNR2", 
  1308.  "Test that indexes are correctly maintained during node fail and node restart"){ 
  1309.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1310.   INITIALIZER(runClearTable);
  1311.   INITIALIZER(createRandomIndex);
  1312.   INITIALIZER(createPkIndex);
  1313.   INITIALIZER(runLoadTable);
  1314.   STEP(runRestarts);
  1315.   STEP(runTransactions2);
  1316.   STEP(runTransactions2);
  1317.   FINALIZER(runVerifyIndex);
  1318.   FINALIZER(createRandomIndex_Drop);
  1319.   FINALIZER(createPkIndex_Drop);
  1320.   FINALIZER(runClearTable);
  1321. }
  1322. TESTCASE("NFNR2_O", 
  1323.  "Test that indexes are correctly maintained during node fail and node restart"){ 
  1324.   TC_PROPERTY("OrderedIndex", 1);
  1325.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1326.   INITIALIZER(runClearTable);
  1327.   INITIALIZER(createRandomIndex);
  1328.   INITIALIZER(createPkIndex);
  1329.   INITIALIZER(runLoadTable);
  1330.   STEP(runRestarts);
  1331.   STEP(runTransactions2);
  1332.   //STEP(runTransactions2);
  1333.   FINALIZER(runVerifyIndex);
  1334.   FINALIZER(createRandomIndex_Drop);
  1335.   FINALIZER(createPkIndex_Drop);
  1336.   FINALIZER(runClearTable);
  1337. }
  1338. TESTCASE("NFNR3", 
  1339.  "Test that indexes are correctly maintained during node fail and node restart"){ 
  1340.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1341.   INITIALIZER(runClearTable);
  1342.   INITIALIZER(createRandomIndex);
  1343.   INITIALIZER(createPkIndex);
  1344.   STEP(runRestarts);
  1345.   STEP(runTransactions3);
  1346.   STEP(runVerifyIndex);
  1347.   FINALIZER(runVerifyIndex);
  1348.   FINALIZER(createPkIndex_Drop);
  1349.   FINALIZER(createRandomIndex_Drop);
  1350.   FINALIZER(runClearTable);
  1351. }
  1352. TESTCASE("NFNR3_O", 
  1353.  "Test that indexes are correctly maintained during node fail and node restart"){ 
  1354.   TC_PROPERTY("OrderedIndex", 1);
  1355.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1356.   INITIALIZER(runClearTable);
  1357.   INITIALIZER(createRandomIndex);
  1358.   INITIALIZER(createPkIndex);
  1359.   STEP(runRestarts);
  1360.   STEP(runTransactions3);
  1361.   STEP(runVerifyIndex);
  1362.   FINALIZER(runVerifyIndex);
  1363.   FINALIZER(createPkIndex_Drop);
  1364.   FINALIZER(createRandomIndex_Drop);
  1365.   FINALIZER(runClearTable);
  1366. }
  1367. TESTCASE("NFNR4", 
  1368.  "Test that indexes are correctly maintained during node fail and node restart"){ 
  1369.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1370.   INITIALIZER(runClearTable);
  1371.   INITIALIZER(createRandomIndex);
  1372.   INITIALIZER(createPkIndex);
  1373.   INITIALIZER(runLoadTable);
  1374.   STEP(runRestarts);
  1375.   STEP(runTransactions1);
  1376.   STEP(runTransactions1);
  1377.   STEP(runTransactions2);
  1378.   STEP(runTransactions2);
  1379.   FINALIZER(runVerifyIndex);
  1380.   FINALIZER(createRandomIndex_Drop);
  1381.   FINALIZER(createPkIndex_Drop);
  1382.   FINALIZER(runClearTable);
  1383. }
  1384. TESTCASE("NFNR4_O", 
  1385.  "Test that indexes are correctly maintained during node fail and node restart"){ 
  1386.   TC_PROPERTY("OrderedIndex", 1);
  1387.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1388.   INITIALIZER(runClearTable);
  1389.   INITIALIZER(createRandomIndex);
  1390.   INITIALIZER(createPkIndex);
  1391.   INITIALIZER(runLoadTable);
  1392.   STEP(runRestarts);
  1393.   STEP(runTransactions1);
  1394.   STEP(runTransactions1);
  1395.   STEP(runTransactions2);
  1396.   STEP(runTransactions2);
  1397.   FINALIZER(runVerifyIndex);
  1398.   FINALIZER(createRandomIndex_Drop);
  1399.   FINALIZER(createPkIndex_Drop);
  1400.   FINALIZER(runClearTable);
  1401. }
  1402. TESTCASE("NFNR5", 
  1403.  "Test that indexes are correctly maintained during node fail and node restart"){ 
  1404.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1405.   TC_PROPERTY("BatchSize", (unsigned)1);
  1406.   INITIALIZER(runClearTable);
  1407.   INITIALIZER(createRandomIndex);
  1408.   INITIALIZER(createPkIndex);
  1409.   INITIALIZER(runLoadTable);
  1410.   STEP(runLQHKEYREF);
  1411.   STEP(runTransactions1);
  1412.   STEP(runTransactions1);
  1413.   STEP(runTransactions2);
  1414.   STEP(runTransactions2);
  1415.   FINALIZER(runVerifyIndex);
  1416.   FINALIZER(createRandomIndex_Drop);
  1417.   FINALIZER(createPkIndex_Drop);
  1418.   FINALIZER(runClearTable);
  1419. }
  1420. TESTCASE("NFNR5_O", 
  1421.  "Test that indexes are correctly maintained during node fail and node restart"){ 
  1422.   TC_PROPERTY("OrderedIndex", 1);
  1423.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1424.   TC_PROPERTY("BatchSize", (unsigned)1);
  1425.   INITIALIZER(runClearTable);
  1426.   INITIALIZER(createRandomIndex);
  1427.   INITIALIZER(createPkIndex);
  1428.   INITIALIZER(runLoadTable);
  1429.   STEP(runLQHKEYREF);
  1430.   STEP(runTransactions1);
  1431.   STEP(runTransactions1);
  1432.   STEP(runTransactions2);
  1433.   STEP(runTransactions2);
  1434.   FINALIZER(runVerifyIndex);
  1435.   FINALIZER(createRandomIndex_Drop);
  1436.   FINALIZER(createPkIndex_Drop);
  1437.   FINALIZER(runClearTable);
  1438. }
  1439. TESTCASE("SR1", 
  1440.  "Test that indexes are correctly maintained during SR"){ 
  1441.   INITIALIZER(runClearTable);
  1442.   INITIALIZER(createRandomIndex);
  1443.   INITIALIZER(createPkIndex);
  1444.   STEP(runSystemRestart1);
  1445.   FINALIZER(runVerifyIndex);
  1446.   FINALIZER(createPkIndex_Drop);
  1447.   FINALIZER(createRandomIndex_Drop);
  1448.   FINALIZER(runClearTable);
  1449. }
  1450. TESTCASE("MixedTransaction", 
  1451.  "Test mixing of index and normal operations"){ 
  1452.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1453.   INITIALIZER(runClearTable);
  1454.   INITIALIZER(createPkIndex);
  1455.   INITIALIZER(runLoadTable);
  1456.   STEP(runMixed1);
  1457.   FINALIZER(createPkIndex_Drop);
  1458.   FINALIZER(runClearTable);
  1459. }
  1460. TESTCASE("SR1_O", 
  1461.  "Test that indexes are correctly maintained during SR"){ 
  1462.   TC_PROPERTY("OrderedIndex", 1);
  1463.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1464.   INITIALIZER(runClearTable);
  1465.   INITIALIZER(createRandomIndex);
  1466.   INITIALIZER(createPkIndex);
  1467.   STEP(runSystemRestart1);
  1468.   FINALIZER(runVerifyIndex);
  1469.   FINALIZER(createPkIndex_Drop);
  1470.   FINALIZER(createRandomIndex_Drop);
  1471.   FINALIZER(runClearTable);
  1472. }
  1473. TESTCASE("BuildDuring", 
  1474.  "Test that index build when running transactions work"){ 
  1475.   TC_PROPERTY("OrderedIndex", (unsigned)0);
  1476.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1477.   TC_PROPERTY("Threads", 1); // # runTransactions4
  1478.   INITIALIZER(runClearTable);
  1479.   STEP(runBuildDuring);
  1480.   STEP(runTransactions4);
  1481.   //STEP(runTransactions4);
  1482.   FINALIZER(runClearTable);
  1483. }
  1484. TESTCASE("BuildDuring_O", 
  1485.  "Test that index build when running transactions work"){ 
  1486.   TC_PROPERTY("OrderedIndex", (unsigned)1);
  1487.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1488.   TC_PROPERTY("Threads", 1); // # runTransactions4
  1489.   INITIALIZER(runClearTable);
  1490.   STEP(runBuildDuring);
  1491.   STEP(runTransactions4);
  1492.   //STEP(runTransactions4);
  1493.   FINALIZER(runClearTable);
  1494. }
  1495. TESTCASE("UniqueNull", 
  1496.  "Test that unique indexes and nulls"){ 
  1497.   TC_PROPERTY("LoggedIndexes", (unsigned)0);
  1498.   INITIALIZER(runClearTable);
  1499.   INITIALIZER(createRandomIndex);
  1500.   INITIALIZER(createPkIndex);
  1501.   INITIALIZER(runLoadTable);
  1502.   STEP(runTransactions1);
  1503.   STEP(runTransactions2);
  1504.   STEP(runUniqueNullTransactions);
  1505.   FINALIZER(runVerifyIndex);
  1506.   FINALIZER(createRandomIndex_Drop);
  1507.   FINALIZER(createPkIndex_Drop);
  1508.   FINALIZER(runClearTable);
  1509. }
  1510. NDBT_TESTSUITE_END(testIndex);
  1512. int main(int argc, const char** argv){
  1513.   ndb_init();
  1514.   return testIndex.execute(argc, argv);
  1515. }
  1517. template class Vector<Attrib*>;