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

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

MySQL数据库

开发平台：

Visual C++

testScan.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 <Vector.hpp>
  23. #include "ScanFunctions.hpp"
  24. #include <random.h>
  26. const NdbDictionary::Table *
  27. getTable(Ndb* pNdb, int i){
  28.   const NdbDictionary::Table* t = NDBT_Tables::getTable(i);
  29.   if (t == NULL){
  30.     return 0;
  31.   }
  32.   return pNdb->getDictionary()->getTable(t->getName());
  33. }
  36. int runLoadTable(NDBT_Context* ctx, NDBT_Step* step){
  37.   
  38.   int records = ctx->getProperty("Rows", ctx->getNumRecords());
  40.   HugoTransactions hugoTrans(*ctx->getTab());
  41.   if (hugoTrans.loadTable(GETNDB(step), records) != 0){
  42.     return NDBT_FAILED;
  43.   }
  44.   return NDBT_OK;
  45. }
  48. int runCreateAllTables(NDBT_Context* ctx, NDBT_Step* step){
  50.   int a = NDBT_Tables::createAllTables(GETNDB(step), false, true); 
  51.   return a;
  52. }
  54. int runDropAllTablesExceptTestTable(NDBT_Context* ctx, NDBT_Step* step){
  56.   for (int i=0; i < NDBT_Tables::getNumTables(); i++){
  58.     const NdbDictionary::Table* tab = NDBT_Tables::getTable(i);
  59.     if (tab == NULL){
  60.       return NDBT_ProgramExit(NDBT_FAILED);
  61.     }
  63.     // Don't drop test table
  64.     if (strcmp(tab->getName(), ctx->getTab()->getName()) == 0){
  65.       continue;
  66.     }
  67.     
  68.     int res = GETNDB(step)->getDictionary()->dropTable(tab->getName());
  69.     if(res == -1){
  70.       return NDBT_FAILED;
  71.     }
  72.   }
  73.   return NDBT_OK;
  74. }
  77. int runLoadAllTables(NDBT_Context* ctx, NDBT_Step* step){
  78.   
  79.   int records = ctx->getNumRecords();
  80.   for (int i=0; i < NDBT_Tables::getNumTables(); i++){
  82.     const NdbDictionary::Table* tab = getTable(GETNDB(step), i);
  83.     if (tab == NULL){ 
  84.       return NDBT_FAILED;
  85.     }
  86.     HugoTransactions hugoTrans(*tab);
  87.     if (hugoTrans.loadTable(GETNDB(step), records) != 0){
  88.       return NDBT_FAILED;
  89.     }    
  90.   }
  91.   return NDBT_OK;
  92. }
  94. char orderedPkIdxName[255];
  96. int createOrderedPkIndex(NDBT_Context* ctx, NDBT_Step* step){
  98.   const NdbDictionary::Table* pTab = ctx->getTab();
  99.   Ndb* pNdb = GETNDB(step);
  100.   
  101.   // Create index    
  102.   BaseString::snprintf(orderedPkIdxName, sizeof(orderedPkIdxName), 
  103.        "IDC_O_PK_%s", pTab->getName());
  104.   NdbDictionary::Index pIdx(orderedPkIdxName);
  105.   pIdx.setTable(pTab->getName());
  106.   pIdx.setType(NdbDictionary::Index::OrderedIndex);
  107.   pIdx.setLogging(false);
  109.   for (int c = 0; c< pTab->getNoOfColumns(); c++){
  110.     const NdbDictionary::Column * col = pTab->getColumn(c);
  111.     if(col->getPrimaryKey()){
  112.       pIdx.addIndexColumn(col->getName());
  113.     }
  114.   }
  115.   
  116.   if (pNdb->getDictionary()->createIndex(pIdx) != 0){
  117.     ndbout << "FAILED! to create index" << endl;
  118.     const NdbError err = pNdb->getDictionary()->getNdbError();
  119.     ERR(err);
  120.     return NDBT_FAILED;
  121.   }
  122.   
  123.   return NDBT_OK;
  124. }
  126. int createOrderedPkIndex_Drop(NDBT_Context* ctx, NDBT_Step* step){
  127.   const NdbDictionary::Table* pTab = ctx->getTab();
  128.   Ndb* pNdb = GETNDB(step);
  129.   
  130.   // Drop index
  131.   if (pNdb->getDictionary()->dropIndex(orderedPkIdxName, 
  132.        pTab->getName()) != 0){
  133.     ndbout << "FAILED! to drop index" << endl;
  134.     ERR(pNdb->getDictionary()->getNdbError());
  135.     return NDBT_FAILED;
  136.   }
  137.   
  138.   return NDBT_OK;
  139. }
  142. int runScanReadRandomTable(NDBT_Context* ctx, NDBT_Step* step){
  143.   int loops = ctx->getNumLoops();
  144.   int records = ctx->getNumRecords();
  145.   int parallelism = ctx->getProperty("Parallelism", 240);
  146.   int abort = ctx->getProperty("AbortProb", 5);
  147.   
  148.   int i = 0;
  149.   while (i<loops) {
  150.     
  151.     int tabNum = myRandom48(NDBT_Tables::getNumTables());
  152.     const NdbDictionary::Table* tab = getTable(GETNDB(step), tabNum);
  153.     if (tab == NULL){
  154.       g_info << "tab == NULL" << endl;
  155.       return NDBT_FAILED;
  156.     }
  157.     
  158.     g_info << "Scan reading from table " << tab->getName() << endl;
  159.     HugoTransactions hugoTrans(*tab);
  160.     
  161.     g_info << i << ": ";
  162.     if (hugoTrans.scanReadRecords(GETNDB(step), records, abort, parallelism) != 0){
  163.       return NDBT_FAILED;
  164.     }
  165.     i++;
  166.   }
  167.   return NDBT_OK;
  168. }
  170. int runInsertUntilStopped(NDBT_Context* ctx, NDBT_Step* step){
  171.   int records = ctx->getNumRecords();
  172.   int i = 0;
  173.   HugoTransactions hugoTrans(*ctx->getTab());
  174.   while (ctx->isTestStopped() == false) {
  175.     g_info << i << ": ";    
  176.     if (hugoTrans.loadTable(GETNDB(step), records, 1) != 0){
  177.       return NDBT_FAILED;
  178.     }
  179.     i++;
  180.   }
  181.   return NDBT_OK;
  182. }
  184. int runInsertDelete(NDBT_Context* ctx, NDBT_Step* step){
  185.   int result = NDBT_OK;
  186.   int records = ctx->getNumRecords();
  187.   int loops = ctx->getNumLoops();
  188.   int i = 0;
  189.   HugoTransactions hugoTrans(*ctx->getTab());
  190.   UtilTransactions utilTrans(*ctx->getTab());
  191.   while (i<loops) {
  192.     g_info << i << ": ";    
  193.     if (hugoTrans.loadTable(GETNDB(step), records, 1) != 0){
  194.       result = NDBT_FAILED;
  195.       break;
  196.     }
  197.     if (utilTrans.clearTable(GETNDB(step),  records) != 0){
  198.       result = NDBT_FAILED;
  199.       break;
  200.     }
  201.     i++;
  202.   }
  204.   ctx->stopTest();
  206.   return result;
  207. }
  209. int runClearTable(NDBT_Context* ctx, NDBT_Step* step){
  210.   int records = ctx->getNumRecords();
  211.   
  212.   UtilTransactions utilTrans(*ctx->getTab());
  213.   if (utilTrans.clearTable2(GETNDB(step),  records) != 0){
  214.     return NDBT_FAILED;
  215.   }
  216.   return NDBT_OK;
  217. }
  219. int runScanDelete(NDBT_Context* ctx, NDBT_Step* step){
  220.   int loops = ctx->getNumLoops();
  221.   int records = ctx->getNumRecords();
  223.   int i = 0;
  224.   UtilTransactions utilTrans(*ctx->getTab());
  225.   HugoTransactions hugoTrans(*ctx->getTab());
  226.   while (i<loops) {
  227.     g_info << i << ": ";
  228.     if (utilTrans.clearTable(GETNDB(step), records) != 0){
  229.       return NDBT_FAILED;
  230.     }
  231.     // Load table, don't allow any primary key violations
  232.     if (hugoTrans.loadTable(GETNDB(step), records, 512, false) != 0){
  233.       return NDBT_FAILED;
  234.     }
  235.     i++;
  236.   }  
  237.   return NDBT_OK;
  238. }
  240. int runScanDelete2(NDBT_Context* ctx, NDBT_Step* step){
  241.   int loops = ctx->getNumLoops();
  242.   int records = ctx->getNumRecords();
  243.   
  244.   int i = 0;
  245.   UtilTransactions utilTrans(*ctx->getTab());
  246.   HugoTransactions hugoTrans(*ctx->getTab());
  248.   while (i<loops) {
  249.     g_info << i << ": ";
  250.     if (utilTrans.clearTable2(GETNDB(step),  records) != 0){
  251.       return NDBT_FAILED;
  252.     }
  253.     // Load table, don't allow any primary key violations
  254.     if (hugoTrans.loadTable(GETNDB(step), records, 512, false) != 0){
  255.       return NDBT_FAILED;
  256.     }
  257.     i++;
  258.   }
  259.   return NDBT_OK;
  260. }
  262. int runVerifyTable(NDBT_Context* ctx, NDBT_Step* step){
  263.   return NDBT_OK;
  264. }
  266. int runScanRead(NDBT_Context* ctx, NDBT_Step* step){
  267.   int loops = ctx->getNumLoops();
  268.   int records = ctx->getProperty("Rows", ctx->getNumRecords());
  269.   int parallelism = ctx->getProperty("Parallelism", 240);
  270.   int abort = ctx->getProperty("AbortProb", 5);
  272.   int i = 0;
  273.   HugoTransactions hugoTrans(*ctx->getTab());
  274.   while (i<loops && !ctx->isTestStopped()) {
  275.     g_info << i << ": ";
  276.     if (hugoTrans.scanReadRecords(GETNDB(step), records, abort, parallelism) != 0){
  277.       return NDBT_FAILED;
  278.     }
  279.     i++;
  280.   }
  281.   return NDBT_OK;
  282. }
  284. int runRandScanRead(NDBT_Context* ctx, NDBT_Step* step){
  285.   int loops = ctx->getNumLoops();
  286.   int records = ctx->getNumRecords();
  287.   int parallelism = ctx->getProperty("Parallelism", 240);
  288.   int abort = ctx->getProperty("AbortProb", 5);
  290.   int i = 0;
  291.   HugoTransactions hugoTrans(*ctx->getTab());
  292.   while (i<loops && !ctx->isTestStopped()) {
  293.     g_info << i << ": ";
  294.     NdbOperation::LockMode lm = (NdbOperation::LockMode)(rand() % 3);
  295.     if (hugoTrans.scanReadRecords(GETNDB(step),
  296.   records, abort, parallelism,
  297.   lm) != 0){
  298.       return NDBT_FAILED;
  299.     }
  300.     i++;
  301.   }
  302.   return NDBT_OK;
  303. }
  305. int runScanReadIndex(NDBT_Context* ctx, NDBT_Step* step){
  306.   int loops = ctx->getNumLoops();
  307.   int records = ctx->getNumRecords();
  308.   int parallelism = ctx->getProperty("Parallelism", 240);
  309.   int abort = ctx->getProperty("AbortProb", 5);
  310.   const NdbDictionary::Index * pIdx = 
  311.     GETNDB(step)->getDictionary()->getIndex(orderedPkIdxName, 
  312.     ctx->getTab()->getName());
  314.   int i = 0;
  315.   HugoTransactions hugoTrans(*ctx->getTab());
  316.   while (pIdx && i<loops && !ctx->isTestStopped()) {
  317.     g_info << i << ": ";
  318.     bool sort = (rand() % 100) > 50 ? true : false;
  319.     NdbOperation::LockMode lm = (NdbOperation::LockMode)(rand() % 3);
  320.     if (hugoTrans.scanReadRecords(GETNDB(step), pIdx,
  321.   records, abort, parallelism,
  322.   lm,
  323.   sort) != 0){
  324.       return NDBT_FAILED;
  325.     }
  326.     i++;
  327.   }
  328.   return NDBT_OK;
  329. }
  331. int runScanReadCommitted(NDBT_Context* ctx, NDBT_Step* step){
  332.   int loops = ctx->getNumLoops();
  333.   int records = ctx->getNumRecords();
  334.   int parallelism = ctx->getProperty("Parallelism", 240);
  335.   int abort = ctx->getProperty("AbortProb", 5);
  337.   int i = 0;
  338.   HugoTransactions hugoTrans(*ctx->getTab());
  339.   while (i<loops && !ctx->isTestStopped()) {
  340.     g_info << i << ": ";
  341.     if (hugoTrans.scanReadRecords(GETNDB(step), records, 
  342.   abort, parallelism, 
  343.   NdbOperation::LM_CommittedRead) != 0){
  344.       return NDBT_FAILED;
  345.     }
  346.     i++;
  347.   }
  348.   return NDBT_OK;
  349. }
  351. int runScanReadError(NDBT_Context* ctx, NDBT_Step* step){
  352.   int result = NDBT_OK;
  353.   int loops = ctx->getNumLoops();
  354.   int records = ctx->getNumRecords();
  355.   int parallelism = 240; // Max parallelism
  356.   int error = ctx->getProperty("ErrorCode");
  357.   NdbRestarter restarter;
  358.   
  359.   int i = 0;
  360.   HugoTransactions hugoTrans(*ctx->getTab());
  361.   while (i<loops && !ctx->isTestStopped()) {
  362.     g_info << i << ": ";
  363.     
  364.     ndbout << "insertErrorInAllNodes("<<error<<")"<<endl;
  365.     if (restarter.insertErrorInAllNodes(error) != 0){
  366.       ndbout << "Could not insert error in all nodes "<<endl;
  367.       return NDBT_FAILED;
  368.     }
  369.     
  370.     if (hugoTrans.scanReadRecords(GETNDB(step), records, 0, parallelism) != 0){
  371.       result = NDBT_FAILED;
  372.     }
  373.     i++;
  374.   }
  375.   
  376.   restarter.insertErrorInAllNodes(0);
  377.   return result;
  378. }
  380. int
  381. runInsertError(NDBT_Context* ctx, NDBT_Step* step){
  382.   int error = ctx->getProperty("ErrorCode");
  383.   NdbRestarter restarter;
  385.   ctx->setProperty("ErrorCode", (Uint32)0);
  386.   if (restarter.insertErrorInAllNodes(error) != 0){
  387.     ndbout << "Could not insert error in all nodes "<<endl;
  388.     return NDBT_FAILED;
  389.   }
  390.   return NDBT_OK;
  391. }     
  393. int runScanReadErrorOneNode(NDBT_Context* ctx, NDBT_Step* step){
  394.   int result = NDBT_OK;
  395.   int loops = ctx->getNumLoops();
  396.   int records = ctx->getNumRecords();
  397.   int parallelism = 240; // Max parallelism
  398.   int error = ctx->getProperty("ErrorCode");
  399.   NdbRestarter restarter;
  400.   int lastId = 0;
  402.   if (restarter.getNumDbNodes() < 2){
  403.       ctx->stopTest();
  404.       return NDBT_OK;
  405.   }
  407.   int i = 0;
  408.   HugoTransactions hugoTrans(*ctx->getTab());
  409.   while (i<loops && result == NDBT_OK) {
  410.     g_info << i << ": ";
  411.         
  412.     int nodeId = restarter.getDbNodeId(lastId);
  413.     lastId = (lastId + 1) % restarter.getNumDbNodes();
  414.     ndbout << "insertErrorInNode("<<nodeId<<", "<<error<<")"<<endl;
  415.     if (restarter.insertErrorInNode(nodeId, error) != 0){
  416.       ndbout << "Could not insert error in node="<<nodeId<<endl;
  417.       return NDBT_FAILED;
  418.     }
  419.     
  420.     for (int j=0; j<10; j++){
  421.       if (hugoTrans.scanReadRecords(GETNDB(step), 
  422.     records, 0, parallelism) != 0)
  423. result = NDBT_FAILED;
  424.     }
  427.     if(restarter.waitClusterStarted(120) != 0){
  428.       g_err << "Cluster failed to restart" << endl;
  429.       result = NDBT_FAILED;
  430.     }
  431.     restarter.insertErrorInAllNodes(0);
  432.     
  433.     i++;
  434.   }
  435.   restarter.insertErrorInAllNodes(0);
  436.   return result;
  437. }
  439. int runRestartAll(NDBT_Context* ctx, NDBT_Step* step){
  441.   NdbRestarter restarter;
  443.   if (restarter.restartAll() != 0){
  444.     ndbout << "Could not restart all nodes"<<endl;
  445.     return NDBT_FAILED;
  446.   }
  448.   if (restarter.waitClusterStarted(120) != 0){
  449.     ndbout << "Could not restarted" << endl;
  450.     return NDBT_FAILED;
  451.   }
  452.       
  453.   return NDBT_OK;
  454. }
  456. static int RANDOM_PARALLELISM = 9999;
  458. int runScanReadUntilStopped(NDBT_Context* ctx, NDBT_Step* step){
  459.   int records = ctx->getNumRecords();
  460.   int i = 0;
  462.   int parallelism = ctx->getProperty("Parallelism", 240);
  463.   int para = parallelism;
  465.   HugoTransactions hugoTrans(*ctx->getTab());
  466.   while (ctx->isTestStopped() == false) {
  467.     if (parallelism == RANDOM_PARALLELISM)
  468.       para = myRandom48(239)+1;
  470.     g_info << i << ": ";
  471.     if (hugoTrans.scanReadRecords(GETNDB(step), records, 0, para) != 0){
  472.       return NDBT_FAILED;
  473.     }
  474.     i++;
  475.   }
  476.   return NDBT_OK;
  477. }
  479. int runScanReadUntilStoppedNoCount(NDBT_Context* ctx, NDBT_Step* step){
  480.   int i = 0;
  481.   HugoTransactions hugoTrans(*ctx->getTab());
  482.   while (ctx->isTestStopped() == false) {
  483.     g_info << i << ": ";
  484.     if (hugoTrans.scanReadRecords(GETNDB(step), 0) != 0){
  485.       return NDBT_FAILED;
  486.     }
  487.     i++;
  488.   }
  489.   return NDBT_OK;
  490. }
  492. int runScanReadUntilStoppedPrintTime(NDBT_Context* ctx, NDBT_Step* step){
  493.   int records = ctx->getNumRecords();
  494.   int i = 0;
  495.   int parallelism = ctx->getProperty("Parallelism", 240);
  496.   NdbTimer timer;
  497.   Ndb* ndb = GETNDB(step);
  500.   HugoTransactions hugoTrans(*ctx->getTab());
  501.   while (ctx->isTestStopped() == false) {
  502.     timer.doReset();
  503.     timer.doStart();
  504.     g_info << i << ": ";
  505.     if (ndb->waitUntilReady() != 0)
  506.       return NDBT_FAILED;      
  507.     if (hugoTrans.scanReadRecords(GETNDB(step), records, 0, parallelism) != 0)
  508.       return NDBT_FAILED;
  509.     timer.doStop();
  510.     if ((timer.elapsedTime()/1000) > 1)
  511.       timer.printTotalTime();
  512.     i++;
  513.   }
  514.   return NDBT_OK;
  515. }
  518. int runPkRead(NDBT_Context* ctx, NDBT_Step* step){
  519.   int loops = ctx->getNumLoops();
  520.   int records = ctx->getNumRecords();
  521.   int i = 0;
  522.   HugoTransactions hugoTrans(*ctx->getTab());
  523.   while (i<loops) {
  524.     g_info << i << ": ";
  525.     if (hugoTrans.pkReadRecords(GETNDB(step), records) != 0){
  526.       return NDBT_FAILED;
  527.     }
  528.     i++;
  529.   }
  530.   return NDBT_OK;
  531. }
  533. int runScanUpdate(NDBT_Context* ctx, NDBT_Step* step){
  534.   int loops = ctx->getNumLoops();
  535.   int records = ctx->getNumRecords();
  536.   int parallelism = ctx->getProperty("Parallelism", 1);
  537.   int abort = ctx->getProperty("AbortProb", 5);
  538.   int i = 0;
  539.   HugoTransactions hugoTrans(*ctx->getTab());
  540.   while (i<loops) {
  541.     g_info << i << ": ";
  543.     if (hugoTrans.scanUpdateRecords(GETNDB(step), records, abort, parallelism) != 0){
  544.       return NDBT_FAILED;
  545.     }
  546.     i++;
  547.   }
  548.   return NDBT_OK;
  549. }
  551. int runScanUpdateUntilStopped(NDBT_Context* ctx, NDBT_Step* step){
  552.   int records = ctx->getNumRecords();
  553.   int i = 0;
  555.   int parallelism = ctx->getProperty("Parallelism", 240);
  556.   int para = parallelism;
  558.   HugoTransactions hugoTrans(*ctx->getTab());
  559.   while (ctx->isTestStopped() == false) {
  560.     if (parallelism == RANDOM_PARALLELISM)
  561.       para = myRandom48(239)+1;
  563.     g_info << i << ": ";
  564.     if (hugoTrans.scanUpdateRecords(GETNDB(step), records, 0, para) == NDBT_FAILED){
  565.       return NDBT_FAILED;
  566.     }
  567.     i++;
  568.   }
  569.   return NDBT_OK;
  570. }
  573. int runScanUpdate2(NDBT_Context* ctx, NDBT_Step* step){
  574.   int loops = ctx->getNumLoops();
  575.   int records = ctx->getNumRecords();
  576.   int parallelism = ctx->getProperty("Parallelism", 240);
  577.   int abort = ctx->getProperty("AbortProb", 5);
  578.   int i = 0;
  579.   HugoTransactions hugoTrans(*ctx->getTab());
  580.   while (i<loops) {
  581.     g_info << i << ": ";
  582.     if (hugoTrans.scanUpdateRecords2(GETNDB(step), records, abort, parallelism) != 0){
  583.       return NDBT_FAILED;
  584.     }
  585.     i++;
  586.   }
  587.   return NDBT_OK;
  588. }
  590. int runLocker(NDBT_Context* ctx, NDBT_Step* step){
  591.   int result = NDBT_OK;
  592.   int records = ctx->getNumRecords();
  593.   HugoTransactions hugoTrans(*ctx->getTab());
  594.   
  595.   if (hugoTrans.lockRecords(GETNDB(step), records, 5, 500) != 0){
  596.     result = NDBT_FAILED;
  597.   }
  598.   ctx->stopTest();
  599.   
  600.   return result;
  601. }
  603. int runRestarter(NDBT_Context* ctx, NDBT_Step* step){
  604.   int result = NDBT_OK;
  605.   int loops = ctx->getNumLoops();
  606.   NdbRestarter restarter;
  607.   int i = 0;
  608.   int lastId = 0;
  609.   int timeout = 240;
  611.   if (restarter.getNumDbNodes() < 2){
  612.       ctx->stopTest();
  613.       return NDBT_OK;
  614.   }
  615.   while(i<loops && result != NDBT_FAILED){
  616.     if(restarter.waitClusterStarted(timeout) != 0){
  617.       g_err << "Cluster failed to start 1" << endl;
  618.       result = NDBT_FAILED;
  619.       break;
  620.     }
  621.     NdbSleep_SecSleep(10);
  622.     
  623.     int nodeId = restarter.getDbNodeId(lastId);
  624.     lastId = (lastId + 1) % restarter.getNumDbNodes();
  625.     if(restarter.restartOneDbNode(nodeId) != 0){
  626.       g_err << "Failed to restartNextDbNode" << endl;
  627.       result = NDBT_FAILED;
  628.       break;
  629.     }    
  630.     i++;
  631.   }
  632.   if(restarter.waitClusterStarted(timeout) != 0){
  633.     g_err << "Cluster failed to start 2" << endl;
  634.     result = NDBT_FAILED;
  635.   }
  637.   ctx->stopTest();
  638.   
  639.   return result;
  640. }
  643. int runStopAndStartNode(NDBT_Context* ctx, NDBT_Step* step){
  644.   int result = NDBT_OK;
  645.   int loops = ctx->getNumLoops();
  646.   NdbRestarter restarter;
  647.   int i = 0;
  648.   int lastId = 0;
  649.   int timeout = 240;
  651.   if (restarter.getNumDbNodes() < 2){
  652.       ctx->stopTest();
  653.       return NDBT_OK;
  654.   }
  655.   while(i<loops && result != NDBT_FAILED){
  656.     if(restarter.waitClusterStarted(timeout) != 0){
  657.       g_err << "Cluster failed to start 1" << endl;
  658.       result = NDBT_FAILED;
  659.       break;
  660.     }
  661.     NdbSleep_SecSleep(1);
  662.     int nodeId = restarter.getDbNodeId(lastId);
  663.     lastId = (lastId + 1) % restarter.getNumDbNodes();
  664.     g_err << "Stopping node " << nodeId << endl;
  666.     if(restarter.restartOneDbNode(nodeId, false, true) != 0){
  667.       g_err << "Failed to restartOneDbNode" << endl;
  668.       result = NDBT_FAILED;
  669.       break;
  670.     }
  671.  
  672.     if(restarter.waitNodesNoStart(&nodeId, 1, timeout) != 0){
  673.       g_err << "Node failed to reach NoStart" << endl;
  674.       result = NDBT_FAILED;
  675.       break;
  676.     }   
  678.     g_info << "Sleeping for 10 secs" << endl;
  679.     NdbSleep_SecSleep(10);
  680.     
  681.     g_err << "Starting node " << nodeId << endl;
  682.     if(restarter.startNodes(&nodeId, 1) != 0){
  683.       g_err << "Failed to start the node" << endl;
  684.       result = NDBT_FAILED;
  685.       break;
  686.     }    
  688.     i++;
  689.   }
  690.   if(restarter.waitClusterStarted(timeout) != 0){
  691.     g_err << "Cluster failed to start 2" << endl;
  692.     result = NDBT_FAILED;
  693.   }
  695.   ctx->stopTest();
  696.   
  697.   return result;
  698. }
  700. int runRestarter9999(NDBT_Context* ctx, NDBT_Step* step){
  701.   int result = NDBT_OK;
  702.   int loops = ctx->getNumLoops();
  703.   NdbRestarter restarter;
  704.   int i = 0;
  705.   int lastId = 0;
  707.   if (restarter.getNumDbNodes() < 2){
  708.       ctx->stopTest();
  709.       return NDBT_OK;
  710.   }
  711.   while(i<loops && result != NDBT_FAILED){
  712.     if(restarter.waitClusterStarted(120) != 0){
  713.       g_err << "Cluster failed to start" << endl;
  714.       result = NDBT_FAILED;
  715.       break;
  716.     }
  717.     NdbSleep_SecSleep(10);
  718.     
  719.     int nodeId = restarter.getDbNodeId(lastId);
  720.     lastId = (lastId + 1) % restarter.getNumDbNodes();
  721.     if(restarter.insertErrorInNode(nodeId, 9999) != 0){
  722.       g_err << "Failed to insertErrorInNode="<<nodeId << endl;
  723.       result = NDBT_FAILED;
  724.       break;
  725.     }    
  726.     NdbSleep_SecSleep(10);
  727.     i++;
  728.   }
  729.   if(restarter.waitClusterStarted(120) != 0){
  730.     g_err << "Cluster failed to start" << endl;
  731.     result = NDBT_FAILED;
  732.   }
  734.   ctx->stopTest();
  735.   
  736.   return result;
  737. }
  740. int runCheckGetValue(NDBT_Context* ctx, NDBT_Step* step){
  741.   const NdbDictionary::Table*  pTab = ctx->getTab();
  742.   int parallelism = ctx->getProperty("Parallelism", 1);
  743.   int records = ctx->getNumRecords();
  744.   int numFailed = 0;
  745.   AttribList alist; 
  746.   alist.buildAttribList(pTab);
  747.   UtilTransactions utilTrans(*pTab);  
  748.   for(size_t i = 0; i < alist.attriblist.size(); i++){
  749.     g_info << (unsigned)i << endl;
  750.     if(utilTrans.scanReadRecords(GETNDB(step), 
  751.  parallelism,
  752.  NdbOperation::LM_Read,
  753.  records,
  754.  alist.attriblist[i]->numAttribs,
  755.  alist.attriblist[i]->attribs) != 0){
  756.       numFailed++;
  757.     }
  758.     if(utilTrans.scanReadRecords(GETNDB(step), 
  759.  parallelism,
  760.  NdbOperation::LM_Read,
  761.  records,
  762.  alist.attriblist[i]->numAttribs,
  763.  alist.attriblist[i]->attribs) != 0){
  764.       numFailed++;
  765.     }
  766.   }
  767.   
  768.   if(numFailed > 0)
  769.     return NDBT_FAILED;
  770.   else
  771.     return NDBT_OK;
  772. }
  774. int runCloseWithoutStop(NDBT_Context* ctx, NDBT_Step* step){
  775.   const NdbDictionary::Table*  pTab = ctx->getTab();
  776.   int records = ctx->getNumRecords();
  777.   int numFailed = 0;
  778.   ScanFunctions scanF(*pTab);
  779.   // Iterate over all possible parallelism valuse
  780.   for (int p = 1; p<240; p++){
  781.     g_info << p << " CloseWithoutStop openScan" << endl;
  782.     if (scanF.scanReadFunctions(GETNDB(step), 
  783. records, 
  784. p,
  785. ScanFunctions::CloseWithoutStop,
  786. false) != 0){
  787.       numFailed++;
  788.     }
  789.     g_info << p << " CloseWithoutStop openScanExclusive" << endl;
  790.     if (scanF.scanReadFunctions(GETNDB(step), 
  791. records, 
  792. p,
  793. ScanFunctions::CloseWithoutStop,
  794. true) != 0){
  795.       numFailed++;
  796.     }
  797.   }
  798.     
  799.   if(numFailed > 0)
  800.     return NDBT_FAILED;
  801.   else
  802.     return NDBT_OK;
  803. }
  805. int runNextScanWhenNoMore(NDBT_Context* ctx, NDBT_Step* step){
  806.   const NdbDictionary::Table*  pTab = ctx->getTab();
  807.   int records = ctx->getNumRecords();
  808.   int numFailed = 0;
  809.   ScanFunctions scanF(*pTab);
  810.   if (scanF.scanReadFunctions(GETNDB(step), 
  811.       records, 
  812.       6,
  813.       ScanFunctions::NextScanWhenNoMore,
  814.       false) != 0){
  815.     numFailed++;
  816.   }
  817.   if (scanF.scanReadFunctions(GETNDB(step), 
  818.       records, 
  819.       6,
  820.       ScanFunctions::NextScanWhenNoMore,
  821.       true) != 0){
  822.     numFailed++;
  823.   }
  824.   
  825.   
  826.   if(numFailed > 0)
  827.     return NDBT_FAILED;
  828.   else
  829.     return NDBT_OK;
  830. }
  832. int runEqualAfterOpenScan(NDBT_Context* ctx, NDBT_Step* step){
  833.   const NdbDictionary::Table*  pTab = ctx->getTab();
  834.   int records = ctx->getNumRecords();
  835.   int numFailed = 0;
  836.   ScanFunctions scanF(*pTab);
  837.   if (scanF.scanReadFunctions(GETNDB(step), 
  838.       records, 
  839.       6,
  840.       ScanFunctions::EqualAfterOpenScan,
  841.       false) == NDBT_OK){
  842.     numFailed++;
  843.   }
  844.   if (scanF.scanReadFunctions(GETNDB(step), 
  845.       records, 
  846.       6,
  847.       ScanFunctions::EqualAfterOpenScan,
  848.       true) == NDBT_OK){
  849.     numFailed++;
  850.   }
  851.   
  852.   
  853.   if(numFailed > 0)
  854.     return NDBT_FAILED;
  855.   else
  856.     return NDBT_OK;
  857. }
  859. int runOnlyOpenScanOnce(NDBT_Context* ctx, NDBT_Step* step){
  860.   const NdbDictionary::Table*  pTab = ctx->getTab();
  861.   int records = ctx->getNumRecords();
  862.   int numFailed = 0;
  863.   ScanFunctions scanF(*pTab);
  864.   g_info << "OnlyOpenScanOnce openScanRead" << endl;
  865.   if (scanF.scanReadFunctions(GETNDB(step), 
  866.       records, 
  867.       6,
  868.       ScanFunctions::OnlyOpenScanOnce,
  869.       false) == 0){
  870.     numFailed++;
  871.   }
  872.   g_info << "OnlyOpenScanOnce openScanExclusive" << endl;
  873.   if (scanF.scanReadFunctions(GETNDB(step), 
  874.       records, 
  875.       6,
  876.       ScanFunctions::OnlyOpenScanOnce,
  877.       true) == 0){
  878.     numFailed++;
  879.   }
  880.   
  881.   
  882.   if(numFailed > 0)
  883.     return NDBT_FAILED;
  884.   else
  885.     return NDBT_OK;
  886. }
  888. int runOnlyOneOpInScanTrans(NDBT_Context* ctx, NDBT_Step* step){
  889.   return NDBT_OK;
  890. }
  892. int runExecuteScanWithoutOpenScan(NDBT_Context* ctx, NDBT_Step* step){
  893.   return NDBT_OK;
  894. }
  896. int runOnlyOneOpBeforeOpenScan(NDBT_Context* ctx, NDBT_Step* step){
  897.     return NDBT_OK;
  898. }
  900. int runOnlyOneScanPerTrans(NDBT_Context* ctx, NDBT_Step* step){
  901.   return NDBT_OK;
  902. }
  904. int runNoCloseTransaction(NDBT_Context* ctx, NDBT_Step* step){
  905.   const NdbDictionary::Table*  pTab = ctx->getTab();
  906.   int loops = ctx->getNumLoops();
  907.   int records = ctx->getNumRecords();
  908.   int numFailed = 0;
  910.   ScanFunctions scanF(*pTab);
  911.   int l = 0;
  912.   while(l < loops){
  913.     if (scanF.scanReadFunctions(GETNDB(step), 
  914. records, 
  915. 6,
  916. ScanFunctions::NoCloseTransaction,
  917. false) != 0){
  918.       numFailed++;
  919.     }
  920.     if (scanF.scanReadFunctions(GETNDB(step), 
  921. records, 
  922. 6,
  923. ScanFunctions::NoCloseTransaction,
  924. true) != 0){
  925.       numFailed++;
  926.     }
  927.     l++;
  928.   }
  929.   
  930.   
  931.   if(numFailed > 0)
  932.     return NDBT_FAILED;
  933.   else
  934.     return NDBT_OK;
  936. }
  938. int runCheckInactivityTimeOut(NDBT_Context* ctx, NDBT_Step* step){
  939.   const NdbDictionary::Table*  pTab = ctx->getTab();
  940.   int records = ctx->getNumRecords();
  941.   int numFailed = 0;
  943.   ScanFunctions scanF(*pTab);
  944.   if (scanF.scanReadFunctions(GETNDB(step), 
  945.       records, 
  946.       1,
  947.       ScanFunctions::CheckInactivityTimeOut,
  948.       false) != NDBT_OK){
  949.     numFailed++;
  950.   }
  951.   if (scanF.scanReadFunctions(GETNDB(step), 
  952.       records, 
  953.       240,
  954.       ScanFunctions::CheckInactivityTimeOut,
  955.       true) != NDBT_OK){
  956.     numFailed++;
  957.   }
  958.   
  959.   if(numFailed > 0)
  960.     return NDBT_FAILED;
  961.   else
  962.     return NDBT_OK;
  964. }
  966. int runCheckInactivityBeforeClose(NDBT_Context* ctx, NDBT_Step* step){
  967.   const NdbDictionary::Table*  pTab = ctx->getTab();
  968.   int records = ctx->getNumRecords();
  969.   int numFailed = 0;
  971.   ScanFunctions scanF(*pTab);
  972.   if (scanF.scanReadFunctions(GETNDB(step), 
  973.       records, 
  974.       16,
  975.       ScanFunctions::CheckInactivityBeforeClose,
  976.       false) != 0){
  977.     numFailed++;
  978.   }
  979.   if (scanF.scanReadFunctions(GETNDB(step), 
  980.       records, 
  981.       240,
  982.       ScanFunctions::CheckInactivityBeforeClose,
  983.       true) != 0){
  984.     numFailed++;
  985.   }
  986.   
  987.   if(numFailed > 0)
  988.     return NDBT_FAILED;
  989.   else
  990.     return NDBT_OK;
  992. }
  994. int runScanRestart(NDBT_Context* ctx, NDBT_Step* step){
  995.   int loops = ctx->getNumLoops();
  996.   int records = ctx->getNumRecords();
  997.   Ndb * pNdb = GETNDB(step);
  998.   const NdbDictionary::Table*  pTab = ctx->getTab();
  1000.   HugoCalculator calc(* pTab);
  1001.   NDBT_ResultRow tmpRow(* pTab);
  1003.   int i = 0;
  1004.   while (i<loops && !ctx->isTestStopped()) {
  1005.     g_info << i++ << ": ";
  1006.     const int record = (rand() % records);
  1007.     g_info << " row=" << record;
  1009.     NdbConnection* pCon = pNdb->startTransaction();
  1010.     NdbScanOperation* pOp = pCon->getNdbScanOperation(pTab->getName());
  1011.     if (pOp == NULL) {
  1012.       ERR(pCon->getNdbError());
  1013.       return NDBT_FAILED;
  1014.     }
  1015.     
  1016.     NdbResultSet* rs = pOp->readTuples();
  1017.     if( rs == 0 ) {
  1018.       ERR(pCon->getNdbError());
  1019.       return NDBT_FAILED;
  1020.     }
  1021.   
  1022.     int check = pOp->interpret_exit_ok();
  1023.     if( check == -1 ) {
  1024.       ERR(pCon->getNdbError());
  1025.       return NDBT_FAILED;
  1026.     }
  1027.     
  1028.     // Define attributes to read  
  1029.     for(int a = 0; a<pTab->getNoOfColumns(); a++){
  1030.       if((tmpRow.attributeStore(a) = 
  1031.   pOp->getValue(pTab->getColumn(a)->getName())) == 0) {
  1032. ERR(pCon->getNdbError());
  1033. return NDBT_FAILED;
  1034.       }
  1035.     } 
  1036.     
  1037.     check = pCon->execute(NoCommit);
  1038.     if( check == -1 ) {
  1039.       ERR(pCon->getNdbError());
  1040.       return NDBT_FAILED;
  1041.     }
  1043.     int res;
  1044.     int row = 0;
  1045.     while(row < record && (res = rs->nextResult()) == 0) {
  1046.       if(calc.verifyRowValues(&tmpRow) != 0){
  1047. abort();
  1048. return NDBT_FAILED;
  1049.       }
  1050.       row++;
  1051.     }
  1052.     if(row != record){
  1053.       ERR(pCon->getNdbError());
  1054.       abort();
  1055.       return NDBT_FAILED;
  1056.     }
  1057.     g_info << " restarting" << endl;
  1058.     if((res = rs->restart()) != 0){
  1059.       ERR(pCon->getNdbError());
  1060.       abort();
  1061.       return NDBT_FAILED;
  1062.     }      
  1064.     row = 0;
  1065.     while((res = rs->nextResult()) == 0) {
  1066.       if(calc.verifyRowValues(&tmpRow) != 0){
  1067. abort();
  1068. return NDBT_FAILED;
  1069.       }
  1070.       row++;
  1071.     }
  1072.     if(res != 1 || row != records){
  1073.       ERR(pCon->getNdbError());
  1074.       abort();
  1075.       return NDBT_FAILED;
  1076.     }
  1077.     pCon->close();
  1078.   }
  1079.   return NDBT_OK;
  1080. }
  1083. NDBT_TESTSUITE(testScan);
  1084. TESTCASE("ScanRead", 
  1085.  "Verify scan requirement: It should be possible "
  1086.  "to read all records in a table without knowing their "
  1087.  "primary key."){
  1088.   INITIALIZER(runLoadTable);
  1089.   TC_PROPERTY("Parallelism", 1);
  1090.   STEP(runScanRead);
  1091.   FINALIZER(runClearTable);
  1092. }
  1093. TESTCASE("ScanRead16", 
  1094.  "Verify scan requirement: It should be possible to scan read "
  1095.  "with parallelism, test with parallelism 16"){
  1096.   INITIALIZER(runLoadTable);
  1097.   TC_PROPERTY("Parallelism", 16);
  1098.   STEP(runScanRead);
  1099.   FINALIZER(runClearTable);
  1100. }
  1101. TESTCASE("ScanRead240", 
  1102.  "Verify scan requirement: It should be possible to scan read with "
  1103.  "parallelism, test with parallelism 240(240 would automatically be "
  1104.  "downgraded to the maximum parallelism value for the current config)"){
  1105.   INITIALIZER(runLoadTable);
  1106.   TC_PROPERTY("Parallelism", 240);
  1107.   STEP(runScanRead);
  1108.   FINALIZER(runClearTable);
  1109. }
  1110. TESTCASE("ScanReadCommitted240", 
  1111.  "Verify scan requirement: It should be possible to scan read committed with "
  1112.  "parallelism, test with parallelism 240(240 would automatically be "
  1113.  "downgraded to the maximum parallelism value for the current config)"){
  1114.   INITIALIZER(runLoadTable);
  1115.   TC_PROPERTY("Parallelism", 240);
  1116.   STEP(runScanReadCommitted);
  1117.   FINALIZER(runClearTable);
  1118. }
  1119. TESTCASE("ScanUpdate", 
  1120.  "Verify scan requirement: It should be possible "
  1121.  "to update all records in a table without knowing their"
  1122.  " primary key."){
  1123.   INITIALIZER(runLoadTable);
  1124.   STEP(runScanUpdate);
  1125.   FINALIZER(runClearTable);
  1126. }
  1127. TESTCASE("ScanUpdate2", 
  1128.  "Verify scan requirement: It should be possible "
  1129.  "to update all records in a table without knowing their"
  1130.  " primary key. Do this efficently by calling nextScanResult(false) "
  1131.  "in order to update the records already fetched to the api in one batch."){
  1132.   INITIALIZER(runLoadTable);
  1133.   TC_PROPERTY("Parallelism", 240);
  1134.   STEP(runScanUpdate2);
  1135.   FINALIZER(runClearTable);
  1136. }
  1137. TESTCASE("ScanDelete", 
  1138.  "Verify scan requirement: It should be possible "
  1139.  "to delete all records in a table without knowing their"
  1140.  " primary key."){
  1141.   INITIALIZER(runLoadTable);
  1142.   STEP(runScanDelete);
  1143.   FINALIZER(runClearTable);
  1144. }
  1145. TESTCASE("ScanDelete2", 
  1146.  "Verify scan requirement: It should be possible "
  1147.  "to delete all records in a table without knowing their"
  1148.  " primary key. Do this efficently by calling nextScanResult(false) "
  1149.  "in order to delete the records already fetched to the api in one batch."){
  1150.   INITIALIZER(runLoadTable);
  1151.   TC_PROPERTY("Parallelism", 240);
  1152.   STEP(runScanDelete2);
  1153.   FINALIZER(runClearTable);
  1154. }
  1155. TESTCASE("ScanUpdateAndScanRead", 
  1156.  "Verify scan requirement: It should be possible to run "
  1157.  "scan read and scan update at the same time"){
  1158.   INITIALIZER(runLoadTable);
  1159.   TC_PROPERTY("Parallelism", 16);
  1160.   STEP(runScanRead);
  1161.   STEP(runScanUpdate);
  1162.   FINALIZER(runClearTable);
  1163. }
  1164. TESTCASE("ScanReadAndLocker", 
  1165.  "Verify scan requirement: The locks are not kept throughout "
  1166.  "the entire scan operation. This means that a scan does not "
  1167.  "lock the entire table, only the records it's currently "
  1168.  "operating on. This will test how scan performs when there are "
  1169.  " a number of 1 second locks in the table"){
  1170.   INITIALIZER(runLoadTable);
  1171.   STEP(runScanReadUntilStopped);
  1172.   STEP(runLocker);
  1173.   FINALIZER(runClearTable);
  1174. }
  1175. TESTCASE("ScanReadAndPkRead", 
  1176.  "Verify scan requirement: The locks are not kept throughout "
  1177.  "the entire scan operation. This means that a scan does not "
  1178.  "lock the entire table, only the records it's currently "
  1179.  "operating on. This will test how scan performs when there are "
  1180.  " a pk reads "){
  1181.   INITIALIZER(runLoadTable);
  1182.   STEPS(runScanRead, 2);
  1183.   STEPS(runPkRead, 2);
  1184.   FINALIZER(runClearTable);
  1185. }
  1186. TESTCASE("ScanRead488", 
  1187.  "Verify scan requirement: It's only possible to have 11 concurrent "
  1188.  "scans per fragment running in Ndb kernel at the same time. "
  1189.  "When this limit is exceeded the scan will be aborted with errorcode "
  1190.  "488."){
  1191.   INITIALIZER(runLoadTable);
  1192.   STEPS(runRandScanRead, 70);
  1193.   FINALIZER(runClearTable);
  1194. }
  1195. TESTCASE("ScanRead488O", 
  1196.  "Verify scan requirement: It's only possible to have 11 concurrent "
  1197.  "scans per fragment running in Ndb kernel at the same time. "
  1198.  "When this limit is exceeded the scan will be aborted with errorcode "
  1199.  "488."){
  1200.   INITIALIZER(createOrderedPkIndex);
  1201.   INITIALIZER(runLoadTable);
  1202.   STEPS(runScanReadIndex, 70);
  1203.   FINALIZER(createOrderedPkIndex_Drop);
  1204.   FINALIZER(runClearTable);
  1205. }
  1206. TESTCASE("ScanRead488_Mixed", 
  1207.  "Verify scan requirement: It's only possible to have 11 concurrent "
  1208.  "scans per fragment running in Ndb kernel at the same time. "
  1209.  "When this limit is exceeded the scan will be aborted with errorcode "
  1210.  "488."){
  1211.   INITIALIZER(createOrderedPkIndex);
  1212.   INITIALIZER(runLoadTable);
  1213.   STEPS(runRandScanRead, 50);
  1214.   STEPS(runScanReadIndex, 50);
  1215.   FINALIZER(createOrderedPkIndex_Drop);
  1216.   FINALIZER(runClearTable);
  1217. }
  1218. TESTCASE("ScanRead488Timeout", 
  1219.  ""){
  1220.   INITIALIZER(runLoadTable);
  1221.   TC_PROPERTY("ErrorCode", 5034);
  1222.   STEPS(runScanRead, 30);
  1223.   STEP(runScanReadError);
  1224.   FINALIZER(runClearTable);
  1225. }
  1226. TESTCASE("ScanRead40", 
  1227.  "Verify scan requirement: Scan with 40 simultaneous threads"){
  1228.   INITIALIZER(runLoadTable);
  1229.   STEPS(runScanRead, 40);
  1230.   FINALIZER(runClearTable);
  1231. }
  1232. TESTCASE("ScanRead100", 
  1233.  "Verify scan requirement: Scan with 100 simultaneous threads"){
  1234.   INITIALIZER(runLoadTable);
  1235.   STEPS(runScanRead, 100);
  1236.   FINALIZER(runClearTable);
  1237. }
  1238. TESTCASE("Scan-bug8262", 
  1239.  ""){
  1240.   TC_PROPERTY("Rows", 1);
  1241.   TC_PROPERTY("ErrorCode", 8035);
  1242.   INITIALIZER(runLoadTable);
  1243.   INITIALIZER(runInsertError); // Will reset error code
  1244.   STEPS(runScanRead, 25);
  1245.   FINALIZER(runInsertError);
  1246.   FINALIZER(runClearTable);
  1247. }
  1248. TESTCASE("ScanRead40RandomTable", 
  1249.  "Verify scan requirement: Scan with 40 simultaneous threads. "
  1250.  "Use random table for the scan"){
  1251.   INITIALIZER(runCreateAllTables);
  1252.   INITIALIZER(runLoadAllTables);
  1253.   STEPS(runScanReadRandomTable, 40);
  1254.   FINALIZER(runDropAllTablesExceptTestTable);
  1255. }
  1256. TESTCASE("ScanRead100RandomTable", 
  1257.  "Verify scan requirement: Scan with 100 simultaneous threads. "
  1258.  "Use random table for the scan"){
  1259.   INITIALIZER(runCreateAllTables);
  1260.   INITIALIZER(runLoadAllTables);
  1261.   STEPS(runScanReadRandomTable, 100);
  1262.   FINALIZER(runDropAllTablesExceptTestTable);
  1263. }
  1264. TESTCASE("ScanReadRandomPrepare",
  1265.  "Create and load tables for ScanRead40RandomNoTableCreate."){
  1266.   INITIALIZER(runCreateAllTables);
  1267.   INITIALIZER(runLoadAllTables);
  1268. }
  1269. TESTCASE("ScanRead40RandomNoTableCreate", 
  1270.  "Verify scan requirement: Scan with 40 simultaneous threads. "
  1271.  "Use random table for the scan. Dont create or load the tables."){
  1272.   STEPS(runScanReadRandomTable, 40);
  1273. }
  1274. TESTCASE("ScanRead100RandomNoTableCreate", 
  1275.  "Verify scan requirement: Scan with 100 simultaneous threads. "
  1276.  "Use random table for the scan. Dont create or load the tables."){
  1277.   STEPS(runScanReadRandomTable, 100);
  1278. }
  1279. TESTCASE("ScanWithLocksAndInserts", 
  1280.  "TR457: This test is added to verify that an insert of a records "
  1281.  "that is already in the database does not delete the record"){  
  1282.   INITIALIZER(runLoadTable);
  1283.   STEPS(runScanReadUntilStopped, 2);
  1284.   STEP(runLocker);
  1285.   STEP(runInsertUntilStopped);
  1286.   FINALIZER(runClearTable);
  1287. }
  1288. TESTCASE("ScanReadAbort", 
  1289.  "Scan requirement: A scan may be aborted by the application "
  1290.  "at any time. This can be performed even if there are more "
  1291.  "tuples to scan."){  
  1292.   INITIALIZER(runLoadTable);
  1293.   TC_PROPERTY("AbortProb", 90);
  1294.   STEPS(runScanRead, 3);
  1295.   FINALIZER(runClearTable);
  1296. }
  1297. TESTCASE("ScanReadAbort15", 
  1298.  "Scan requirement: A scan may be aborted by the application "
  1299.  "at any time. This can be performed even if there are more "
  1300.  "tuples to scan. Use parallelism 15"){  
  1301.   INITIALIZER(runLoadTable);
  1302.   TC_PROPERTY("Parallelism", 15);
  1303.   TC_PROPERTY("AbortProb", 90);
  1304.   STEPS(runScanRead, 3);
  1305.   FINALIZER(runClearTable);
  1306. }
  1307. TESTCASE("ScanReadAbort240", 
  1308.  "Scan requirement: A scan may be aborted by the application "
  1309.  "at any time. This can be performed even if there are more "
  1310.  "tuples to scan. Use parallelism 240(it will be downgraded to max para for this config)"){  
  1311.   INITIALIZER(runLoadTable);
  1312.   TC_PROPERTY("Parallelism", 240);
  1313.   TC_PROPERTY("AbortProb", 90);
  1314.   STEPS(runScanRead, 3);
  1315.   FINALIZER(runClearTable);
  1316. }
  1317. TESTCASE("ScanUpdateAbort16", 
  1318.  "Scan requirement: A scan may be aborted by the application "
  1319.  "at any time. This can be performed even if there are more "
  1320.  "tuples to scan. Use parallelism 16"){  
  1321.   INITIALIZER(runLoadTable);
  1322.   TC_PROPERTY("Parallelism", 16);
  1323.   TC_PROPERTY("AbortProb", 90);
  1324.   STEPS(runScanUpdate, 3);
  1325.   FINALIZER(runClearTable);
  1326. }
  1327. TESTCASE("ScanUpdateAbort240", 
  1328.  "Scan requirement: A scan may be aborted by the application "
  1329.  "at any time. This can be performed even if there are more "
  1330.  "tuples to scan. Use parallelism 240(it will be downgraded to max para for this config)"){  
  1331.   INITIALIZER(runLoadTable);
  1332.   TC_PROPERTY("Parallelism", 240);
  1333.   TC_PROPERTY("AbortProb", 90);
  1334.   STEPS(runScanUpdate, 3);
  1335.   FINALIZER(runClearTable);
  1336. }
  1337. TESTCASE("CheckGetValue", 
  1338.  "Check that we can call getValue to read attributes"
  1339.  "Especially interesting to see if we can read only the"
  1340.  " first, last or any two attributes from the table"){
  1341.   INITIALIZER(runLoadTable);
  1342.   STEP(runCheckGetValue);
  1343.   VERIFIER(runScanRead);
  1344.   FINALIZER(runClearTable);
  1345. }
  1346. TESTCASE("CloseWithoutStop", 
  1347.  "Check that we can close the scanning transaction without calling "
  1348.  "stopScan"){
  1349.   INITIALIZER(runLoadTable);
  1350.   STEP(runCloseWithoutStop);
  1351.   VERIFIER(runScanRead);
  1352.   FINALIZER(runClearTable);
  1353. }
  1354. TESTCASE("NextScanWhenNoMore", 
  1355.  "Check that we can call nextScanResult when there are no more "
  1356.  "records, and that it returns a valid value"){
  1357.   INITIALIZER(runLoadTable);
  1358.   STEP(runNextScanWhenNoMore);
  1359.   VERIFIER(runScanRead);
  1360.   FINALIZER(runClearTable);
  1361. }
  1362. TESTCASE("EqualAfterOpenScan", 
  1363.  "Check that we can't call equal after openScan"){
  1364.   STEP(runEqualAfterOpenScan);
  1365. }
  1366. TESTCASE("ExecuteScanWithoutOpenScan", 
  1367.  "Check that we can't call executeScan without defining a scan "
  1368.          "with openScan"){
  1369.   INITIALIZER(runLoadTable);
  1370.   STEP(runExecuteScanWithoutOpenScan);
  1371.   VERIFIER(runScanRead);
  1372.   FINALIZER(runClearTable);
  1373. }
  1374. TESTCASE("OnlyOpenScanOnce", 
  1375.  "Check that we may only call openScan once in the same trans"){
  1376.   INITIALIZER(runLoadTable);
  1377.   STEP(runOnlyOpenScanOnce);
  1378.   VERIFIER(runScanRead);
  1379.   FINALIZER(runClearTable);
  1380. }
  1381. TESTCASE("OnlyOneOpInScanTrans", 
  1382.  "Check that we can have only one operation in a scan trans"){
  1383.   INITIALIZER(runLoadTable);
  1384.   STEP(runOnlyOneOpInScanTrans);
  1385.   VERIFIER(runScanRead);
  1386.   FINALIZER(runClearTable);
  1387. }
  1388. TESTCASE("OnlyOneOpBeforeOpenScan", 
  1389.  "Check that we can have only one operation in a trans defined "
  1390.  "when calling openScan "){
  1391.   INITIALIZER(runLoadTable);
  1392.   STEP(runOnlyOneOpBeforeOpenScan);
  1393.   VERIFIER(runScanRead);
  1394.   FINALIZER(runClearTable);
  1395. }
  1396. TESTCASE("OnlyOneScanPerTrans", 
  1397.  "Check that we can have only one scan operation in a trans"){
  1398.   INITIALIZER(runLoadTable);
  1399.   STEP(runOnlyOneScanPerTrans);
  1400.   VERIFIER(runScanRead);
  1401.   FINALIZER(runClearTable);
  1402. }
  1403. TESTCASE("NoCloseTransaction", 
  1404.  "Check behaviour when close transaction is not called "){
  1405.   INITIALIZER(runLoadTable);
  1406.   STEP(runNoCloseTransaction);
  1407.   VERIFIER(runScanRead);
  1408.   FINALIZER(runClearTable);
  1409. }
  1410. TESTCASE("CheckInactivityTimeOut", 
  1411.  "Check behaviour when the api sleeps for a long time before continuing scan "){
  1412.   INITIALIZER(runLoadTable);
  1413.   STEP(runCheckInactivityTimeOut);
  1414.   VERIFIER(runScanRead);
  1415.   FINALIZER(runClearTable);
  1416. }
  1417. TESTCASE("CheckInactivityBeforeClose", 
  1418.  "Check behaviour when the api sleeps for a long time before calling close scan "){
  1419.   INITIALIZER(runLoadTable);
  1420.   STEP(runCheckInactivityBeforeClose);
  1421.   VERIFIER(runScanRead);
  1422.   FINALIZER(runClearTable);
  1423. }
  1424. TESTCASE("ScanReadError5021", 
  1425.  "Scan and insert error 5021, one node is expected to crash"){
  1426.   INITIALIZER(runLoadTable);
  1427.   TC_PROPERTY("ErrorCode", 5021);
  1428.   STEP(runScanReadErrorOneNode);
  1429.   FINALIZER(runClearTable);
  1430. }
  1431. TESTCASE("ScanReadError5022", 
  1432.  "Scan and insert error 5022, one node is expected to crash"){
  1433.   INITIALIZER(runLoadTable);
  1434.   TC_PROPERTY("ErrorCode", 5022);
  1435.   TC_PROPERTY("NodeNumber", 2);
  1436.   STEP(runScanReadErrorOneNode);
  1437.   FINALIZER(runClearTable);
  1438. }
  1439. TESTCASE("ScanReadError5023", 
  1440.  "Scan and insert error 5023"){
  1441.   INITIALIZER(runLoadTable);
  1442.   TC_PROPERTY("ErrorCode", 5023);
  1443.   STEP(runScanReadError);
  1444.   FINALIZER(runClearTable);
  1445. }
  1446. TESTCASE("ScanReadError5024", 
  1447.  "Scan and insert error 5024"){
  1448.   INITIALIZER(runLoadTable);
  1449.   TC_PROPERTY("ErrorCode", 5024);
  1450.   STEP(runScanReadError);
  1451.   FINALIZER(runClearTable);
  1452. }
  1453. TESTCASE("ScanReadError5025", 
  1454.  "Scan and insert error 5025"){
  1455.   INITIALIZER(runLoadTable);
  1456.   TC_PROPERTY("ErrorCode", 5025);
  1457.   STEP(runScanReadError);
  1458.   FINALIZER(runClearTable);
  1459. }
  1460. TESTCASE("ScanReadError5030", 
  1461.  "Scan and insert error 5030."
  1462.  "Drop all SCAN_NEXTREQ signals in LQH until the node is "
  1463.  "shutdown with SYSTEM_ERROR because of scan fragment timeout"){
  1464.   INITIALIZER(runLoadTable);
  1465.   TC_PROPERTY("ErrorCode", 5030);
  1466.   STEP(runScanReadErrorOneNode);
  1467.   FINALIZER(runClearTable);
  1468. }
  1469. TESTCASE("ScanReadRestart", 
  1470.  "Scan requirement:A scan should be able to start and "
  1471.  "complete during node recovery and when one or more nodes "
  1472.  "in the cluster is down.Use random parallelism "){
  1473.   INITIALIZER(runLoadTable);
  1474.   TC_PROPERTY("Parallelism", RANDOM_PARALLELISM); // Random
  1475.   STEP(runScanReadUntilStopped);
  1476.   STEP(runRestarter);
  1477.   FINALIZER(runClearTable);
  1478. }
  1479. TESTCASE("ScanUpdateRestart", 
  1480.  "Scan requirement:A scan should be able to start and "
  1481.  "complete during node recovery and when one or more nodes "
  1482.  "in the cluster is down. Use random parallelism"){
  1483.   INITIALIZER(runLoadTable);
  1484.   TC_PROPERTY("Parallelism", RANDOM_PARALLELISM); // Random
  1485.   STEP(runScanUpdateUntilStopped);
  1486.   STEP(runRestarter);
  1487.   FINALIZER(runClearTable);
  1488. }
  1489. #if 0
  1490. TESTCASE("ScanReadRestart9999", 
  1491.  "Scan requirement:A scan should be able to start and "
  1492.  "complete during node recovery and when one or more nodes "
  1493.  "in the cluster is down. Use parallelism 240."
  1494.  "Restart using error insert 9999"){
  1495.   INITIALIZER(runLoadTable);
  1496.   TC_PROPERTY("Parallelism", 240);
  1497.   STEP(runScanReadUntilStopped);
  1498.   STEP(runRestarter9999);
  1499.   FINALIZER(runClearTable);
  1500. }
  1501. TESTCASE("ScanUpdateRestart9999", 
  1502.  "Scan requirement:A scan should be able to start and "
  1503.  "complete during node recovery and when one or more nodes "
  1504.  "in the cluster is down. Use parallelism 240."
  1505.  "Restart using error insert 9999"){
  1506.   INITIALIZER(runLoadTable);
  1507.   TC_PROPERTY("Parallelism", 240);
  1508.   STEP(runScanReadUntilStopped);
  1509.   STEP(runScanUpdateUntilStopped);
  1510.   STEP(runRestarter9999);
  1511.   FINALIZER(runClearTable);
  1512. }
  1513. #endif
  1514. TESTCASE("InsertDelete", 
  1515.  "Load and delete all while scan updating and scan readingn"
  1516.  "Alexander Lukas special"){
  1517.   INITIALIZER(runClearTable);
  1518.   STEP(runScanReadUntilStoppedNoCount);
  1519.   STEP(runScanUpdateUntilStopped);
  1520.   STEP(runInsertDelete);
  1521.   FINALIZER(runClearTable);
  1522. }
  1523. TESTCASE("CheckAfterTerror", 
  1524.  "Check that we can still scan read after this terror of NdbApi"){
  1525.   INITIALIZER(runLoadTable);
  1526.   STEPS(runScanRead, 5);
  1527.   FINALIZER(runClearTable);
  1528. }
  1529. TESTCASE("ScanReadWhileNodeIsDown", 
  1530.  "Scan requirement:A scan should be able to run as fast when  "
  1531.  "one or more nodes in the cluster is down."){
  1532.   INITIALIZER(runLoadTable);
  1533.   STEP(runScanReadUntilStoppedPrintTime);
  1534.   STEP(runStopAndStartNode);
  1535.   FINALIZER(runClearTable);
  1536. }
  1537. TESTCASE("ScanRestart", 
  1538.  "Verify restart functionallity"){
  1539.   INITIALIZER(runLoadTable);
  1540.   STEP(runScanRestart);
  1541.   FINALIZER(runClearTable);
  1542. }
  1543. NDBT_TESTSUITE_END(testScan);
  1545. int main(int argc, const char** argv){
  1546.   ndb_init();
  1547.   myRandom48Init(NdbTick_CurrentMillisecond());
  1548.   return testScan.execute(argc, argv);
  1549. }
  1551. template class Vector<Attrib*>;