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

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

MySQL数据库

开发平台：

Visual C++

testBasic.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_Test.hpp>
  18. #include <NDBT_ReturnCodes.h>
  19. #include <HugoTransactions.hpp>
  20. #include <UtilTransactions.hpp>
  21. #include <NdbRestarter.hpp>
  23. #define GETNDB(ps) ((NDBT_NdbApiStep*)ps)->getNdb()
  26. /**
  27.  * TODO 
  28.  *  dirtyWrite, write, dirtyUpdate
  29.  *  delete should be visible to same transaction
  30.  *  
  31.  */
  32. int runLoadTable2(NDBT_Context* ctx, NDBT_Step* step)
  33. {
  34.   int records = ctx->getNumRecords();
  35.   HugoTransactions hugoTrans(*ctx->getTab());
  36.   if (hugoTrans.loadTable(GETNDB(step), records, 512, false, 0, true) != 0){
  37.     return NDBT_FAILED;
  38.   }
  39.   return NDBT_OK;
  40. }
  42. int runLoadTable(NDBT_Context* ctx, NDBT_Step* step)
  43. {
  44.   int records = ctx->getNumRecords();
  45.   HugoTransactions hugoTrans(*ctx->getTab());
  46.   if (hugoTrans.loadTable(GETNDB(step), records) != 0){
  47.     return NDBT_FAILED;
  48.   }
  49.   return NDBT_OK;
  50. }
  52. int runInsert(NDBT_Context* ctx, NDBT_Step* step){
  54.   int records = ctx->getNumRecords();
  55.   HugoTransactions hugoTrans(*ctx->getTab());
  56.   // Insert records, dont allow any 
  57.   // errors(except temporary) while inserting
  58.   if (hugoTrans.loadTable(GETNDB(step), records, 1, false) != 0){
  59.     return NDBT_FAILED;
  60.   }
  61.   return NDBT_OK;
  62. }
  64. int runInsertTwice(NDBT_Context* ctx, NDBT_Step* step){
  66.   int records = ctx->getNumRecords();
  67.   HugoTransactions hugoTrans(*ctx->getTab());
  68.   // Insert records, expect primary key violation 630
  69.   if (hugoTrans.loadTable(GETNDB(step), records, 1, false) != 630){
  70.     return NDBT_FAILED;
  71.   }
  72.   return NDBT_OK;
  73. }
  75. int runVerifyInsert(NDBT_Context* ctx, NDBT_Step* step){
  76.   int records = ctx->getNumRecords();
  77.   
  78.   HugoTransactions hugoTrans(*ctx->getTab());
  79.   if (hugoTrans.pkDelRecords(GETNDB(step),  records, 1, false) != 0){
  80.     return NDBT_FAILED;
  81.   }
  82.   return NDBT_OK;
  83. }
  85. int runInsertUntilStopped(NDBT_Context* ctx, NDBT_Step* step){
  86.   int records = ctx->getNumRecords();
  87.   int i = 0;
  88.   HugoTransactions hugoTrans(*ctx->getTab());
  89.   while (ctx->isTestStopped() == false) {
  90.     g_info << i << ": ";    
  91.     if (hugoTrans.loadTable(GETNDB(step), records) != 0){
  92.       g_info << endl;
  93.       return NDBT_FAILED;
  94.     }
  95.     i++;
  96.   }
  97.   g_info << endl;
  98.   return NDBT_OK;
  99. }
  101. int runClearTable(NDBT_Context* ctx, NDBT_Step* step){
  102.   int records = ctx->getNumRecords();
  103.   int batchSize = ctx->getProperty("BatchSize", 1);
  104.   
  105.   HugoTransactions hugoTrans(*ctx->getTab());
  106.   if (hugoTrans.pkDelRecords(GETNDB(step),  records, batchSize) != 0){
  107.     return NDBT_FAILED;
  108.   }
  109.   return NDBT_OK;
  110. }
  112. int runPkDelete(NDBT_Context* ctx, NDBT_Step* step){
  113.   int loops = ctx->getNumLoops();
  114.   int records = ctx->getNumRecords();
  116.   int i = 0;
  117.   HugoTransactions hugoTrans(*ctx->getTab());
  118.   while (i<loops) {
  119.     g_info << i << ": ";
  120.     if (hugoTrans.pkDelRecords(GETNDB(step),  records) != 0){
  121.       g_info << endl;
  122.       return NDBT_FAILED;
  123.     }
  124.     // Load table, don't allow any primary key violations
  125.     if (hugoTrans.loadTable(GETNDB(step), records, 512, false) != 0){
  126.       g_info << endl;
  127.       return NDBT_FAILED;
  128.     }
  129.     i++;
  130.   }  
  131.   g_info << endl;
  132.   return NDBT_OK;
  133. }
  136. int runPkRead(NDBT_Context* ctx, NDBT_Step* step){
  137.   int loops = ctx->getNumLoops();
  138.   int records = ctx->getNumRecords();
  139.   int batchSize = ctx->getProperty("BatchSize", 1);
  140.   int i = 0;
  141.   HugoTransactions hugoTrans(*ctx->getTab());
  142.   while (i<loops) {
  143.     g_info << i << ": ";
  144.     if (hugoTrans.pkReadRecords(GETNDB(step), records, batchSize) != NDBT_OK){
  145.       g_info << endl;
  146.       return NDBT_FAILED;
  147.     }
  148.     i++;
  149.   }
  150.   g_info << endl;
  151.   return NDBT_OK;
  152. }
  154. int runPkDirtyRead(NDBT_Context* ctx, NDBT_Step* step){
  155.   int loops = ctx->getNumLoops();
  156.   int records = ctx->getNumRecords();
  157.   int batchSize = ctx->getProperty("BatchSize", 1);
  158.   int i = 0;
  159.   bool dirty = true;
  160.   HugoTransactions hugoTrans(*ctx->getTab());
  161.   while (i<loops) {
  162.     g_info << i << ": ";
  163.     if (hugoTrans.pkReadRecords(GETNDB(step), records, batchSize, 
  164. NdbOperation::LM_CommittedRead) != NDBT_OK){
  165.       g_info << endl;
  166.       return NDBT_FAILED;
  167.     }
  168.     i++;
  169.   }
  170.   g_info << endl;
  171.   return NDBT_OK;
  172. }
  174. int runPkReadUntilStopped(NDBT_Context* ctx, NDBT_Step* step){
  175.   int records = ctx->getNumRecords();
  176.   int batchSize = ctx->getProperty("BatchSize", 1);
  177.   int i = 0;
  178.   HugoTransactions hugoTrans(*ctx->getTab());
  179.   while (ctx->isTestStopped() == false) {
  180.     g_info << i << ": ";
  181.     if (hugoTrans.pkReadRecords(GETNDB(step), records, batchSize) != 0){
  182.       g_info << endl;
  183.       return NDBT_FAILED;
  184.     }
  185.     i++;
  186.   }
  187.   g_info << endl;
  188.   return NDBT_OK;
  189. }
  191. int runPkUpdate(NDBT_Context* ctx, NDBT_Step* step){
  192.   int loops = ctx->getNumLoops();
  193.   int records = ctx->getNumRecords();
  194.   int batchSize = ctx->getProperty("BatchSize", 1);
  195.   int i = 0;
  196.   HugoTransactions hugoTrans(*ctx->getTab());
  197.   while (i<loops) {
  198.     g_info << "|- " << i << ": ";
  199.     if (hugoTrans.pkUpdateRecords(GETNDB(step), records, batchSize) != 0){
  200.       g_info << endl;
  201.       return NDBT_FAILED;
  202.     }
  203.     i++;
  204.   }
  205.   g_info << endl;
  206.   return NDBT_OK;
  207. }
  209. int runPkUpdateUntilStopped(NDBT_Context* ctx, NDBT_Step* step){
  210.   int records = ctx->getNumRecords();
  211.   int batchSize = ctx->getProperty("BatchSize", 1);
  212.   int i = 0;
  213.   HugoTransactions hugoTrans(*ctx->getTab());
  214.   while (ctx->isTestStopped()) {
  215.     g_info << i << ": ";
  216.     if (hugoTrans.pkUpdateRecords(GETNDB(step), records, batchSize) != 0){
  217.       g_info << endl;
  218.       return NDBT_FAILED;
  219.     }
  220.     i++;
  221.   }
  222.   g_info << endl;
  223.   return NDBT_OK;
  224. }
  226. int runLocker(NDBT_Context* ctx, NDBT_Step* step){
  227.   int result = NDBT_OK;
  228.   int records = ctx->getNumRecords();
  229.   HugoTransactions hugoTrans(*ctx->getTab());
  230.   
  231.   if (hugoTrans.lockRecords(GETNDB(step), records, 10, 500) != 0){
  232.     result = NDBT_FAILED;
  233.   }
  234.   ctx->stopTest();
  235.   
  236.   return result;
  237. }
  239. int
  240. runInsertOne(NDBT_Context* ctx, NDBT_Step* step){
  241.   
  242.   if(ctx->getProperty("InsertCommitted", (Uint32)0) != 0){
  243.     abort();
  244.   }
  246.   while(ctx->getProperty("Read1Performed", (Uint32)0) == 0){
  247.     NdbSleep_MilliSleep(20);
  248.   }
  249.   
  250.   HugoTransactions hugoTrans(*ctx->getTab());
  251.   
  252.   if (hugoTrans.loadTable(GETNDB(step), 1, 1) != 0){
  253.     return NDBT_FAILED;
  254.   }
  256.   ctx->setProperty("InsertCommitted", 1);
  258.   NdbSleep_SecSleep(2);
  260.   return NDBT_OK;
  261. }
  263. static
  264. int
  265. readOneNoCommit(Ndb* pNdb, NdbConnection* pTrans, 
  266. const NdbDictionary::Table* tab,NDBT_ResultRow * row){
  267.   int a;
  268.   NdbOperation * pOp = pTrans->getNdbOperation(tab->getName());
  269.   if (pOp == NULL){
  270.     ERR(pTrans->getNdbError());
  271.     return NDBT_FAILED;
  272.   }
  273.   
  274.   HugoTransactions tmp(*tab);
  276.   int check = pOp->readTuple();
  277.   if( check == -1 ) {
  278.     ERR(pTrans->getNdbError());
  279.     return NDBT_FAILED;
  280.   }
  281.   
  282.   // Define primary keys
  283.   for(a = 0; a<tab->getNoOfColumns(); a++){
  284.     if (tab->getColumn(a)->getPrimaryKey() == true){
  285.       if(tmp.equalForAttr(pOp, a, 0) != 0){
  286. ERR(pTrans->getNdbError());
  287. return NDBT_FAILED;
  288.       }
  289.     }
  290.   }
  291.   
  292.   // Define attributes to read  
  293.   for(a = 0; a<tab->getNoOfColumns(); a++){
  294.     if((row->attributeStore(a) = 
  295. pOp->getValue(tab->getColumn(a)->getName())) == 0) {
  296.       ERR(pTrans->getNdbError());
  297.       return NDBT_FAILED;
  298.     }
  299.   }
  301.   check = pTrans->execute(NoCommit);     
  302.   if( check == -1 ) {
  303.     const NdbError err = pTrans->getNdbError(); 
  304.     ERR(err);
  305.     return err.code;
  306.   }
  307.   return NDBT_OK;
  308. }
  310. int
  311. runReadOne(NDBT_Context* ctx, NDBT_Step* step){
  313.   Ndb* pNdb = GETNDB(step);
  314.   const NdbDictionary::Table* tab = ctx->getTab();
  315.   NDBT_ResultRow row1(*tab);
  316.   NDBT_ResultRow row2(*tab);  
  318.   if(ctx->getProperty("Read1Performed", (Uint32)0) != 0){
  319.     abort();
  320.   }
  322.   if(ctx->getProperty("InsertCommitted", (Uint32)0) != 0){
  323.     abort();
  324.   }
  325.   
  326.   NdbConnection * pTrans = pNdb->startTransaction();
  327.   if (pTrans == NULL) {
  328.     abort();
  329.   }    
  331.   // Read a record with NoCommit
  332.   // Since the record isn't inserted yet it wil return 626
  333.   const int res1 = readOneNoCommit(pNdb, pTrans, tab, &row1);
  334.   g_info << "|- res1 = " << res1 << endl;
  336.   ctx->setProperty("Read1Performed", 1);
  337.   
  338.   while(ctx->getProperty("InsertCommitted", (Uint32)0) == 0 && 
  339. !ctx->isTestStopped()){
  340.     g_info << "|- Waiting for insert" << endl;
  341.     NdbSleep_MilliSleep(20);
  342.   }
  343.   
  344.   if(ctx->isTestStopped()){
  345.     abort();
  346.   }
  348.   // Now the record should have been inserted
  349.   // Read it once again in the same transaction
  350.   // Should also reutrn 626 if reads are consistent
  352.   // NOTE! Currently it's not possible to start a new operation
  353.   // on a transaction that has returned an error code
  354.   // This is wat fail in this test
  355.   // MASV 20030624
  356.   const int res2 = readOneNoCommit(pNdb, pTrans, tab, &row2);
  358.   pTrans->execute(Commit);
  359.   pNdb->closeTransaction(pTrans);
  360.   g_info << "|- res2 = " << res2 << endl;
  362.   if (res2 == 626 && res1 == res2)    
  363.     return NDBT_OK;
  364.   else
  365.     return NDBT_FAILED;
  366. }
  368. int runFillTable(NDBT_Context* ctx, NDBT_Step* step){
  369.   int batch = 512; //4096;
  370.   HugoTransactions hugoTrans(*ctx->getTab());
  371.   if (hugoTrans.fillTable(GETNDB(step), batch ) != 0){
  372.     return NDBT_FAILED;
  373.   }
  374.   return NDBT_OK;
  375. }
  377. int runClearTable2(NDBT_Context* ctx, NDBT_Step* step){
  378.   int records = ctx->getNumRecords();
  379.   
  380.   UtilTransactions utilTrans(*ctx->getTab());
  381.   if (utilTrans.clearTable2(GETNDB(step), records, 240) != 0){
  382.     return NDBT_FAILED;
  383.   }
  384.   return NDBT_OK;
  385. }
  387. #define CHECK(b) if (!(b)) { 
  388.   ndbout << "ERR: "<< step->getName() 
  389.          << " failed on line " << __LINE__ << endl; 
  390.   result = NDBT_FAILED; 
  391.   break; }
  393. int runNoCommitSleep(NDBT_Context* ctx, NDBT_Step* step){
  394.   int result = NDBT_OK;
  395.   HugoOperations hugoOps(*ctx->getTab());
  396.   Ndb* pNdb = GETNDB(step);
  397.   int sleepTime = 100; // ms
  398.   for (int i = 2; i < 8; i++){
  400.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  401.     CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0);
  402.     CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  404.     ndbout << i <<": Sleeping for " << sleepTime << " ms" << endl;
  405.     NdbSleep_MilliSleep(sleepTime);
  407.     // Dont care about result of these ops
  408.     hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive);
  409.     hugoOps.closeTransaction(pNdb);
  411.     sleepTime = sleepTime *i;
  412.   }
  414.   hugoOps.closeTransaction(pNdb);
  416.   return result;
  417. }
  419. int runCommit626(NDBT_Context* ctx, NDBT_Step* step){
  420.   int result = NDBT_OK;
  421.   HugoOperations hugoOps(*ctx->getTab());
  422.   Ndb* pNdb = GETNDB(step);
  424.   do{
  425.     // Commit transaction
  426.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  427.     CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0);
  428.     CHECK(hugoOps.execute_Commit(pNdb) == 626);
  429.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  431.     // Commit transaction
  432.     // Multiple operations
  433.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  434.     CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0);
  435.     CHECK(hugoOps.pkReadRecord(pNdb, 2, 1, NdbOperation::LM_Exclusive) == 0);
  436.     CHECK(hugoOps.pkReadRecord(pNdb, 3, 1, NdbOperation::LM_Exclusive) == 0);
  437.     CHECK(hugoOps.execute_Commit(pNdb) == 626);
  438.   }while(false);
  440.   hugoOps.closeTransaction(pNdb);
  441.   
  442.   return result;
  443. }
  445. int runCommit630(NDBT_Context* ctx, NDBT_Step* step){
  446.   int result = NDBT_OK;
  447.   HugoOperations hugoOps(*ctx->getTab());
  448.   Ndb* pNdb = GETNDB(step);
  450.   do{
  451.     // Commit transaction
  452.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  453.     CHECK(hugoOps.pkInsertRecord(pNdb, 1) == 0);
  454.     CHECK(hugoOps.execute_Commit(pNdb) == 630);
  455.   }while(false);
  457.   hugoOps.closeTransaction(pNdb);
  459.   return result;
  460. }
  462. int runCommit_TryCommit626(NDBT_Context* ctx, NDBT_Step* step){
  463.   int result = NDBT_OK;
  464.   HugoOperations hugoOps(*ctx->getTab());
  465.   Ndb* pNdb = GETNDB(step);
  467.   do{
  468.     // Commit transaction, TryCommit
  469.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  470.     CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0);
  471.     CHECK(hugoOps.execute_Commit(pNdb, TryCommit) == 626);
  472.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  474.     // Commit transaction, TryCommit
  475.     // Several operations in one transaction
  476.     // The insert is OK
  477.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  478.     CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0);
  479.     CHECK(hugoOps.pkReadRecord(pNdb, 2, 1, NdbOperation::LM_Exclusive) == 0);
  480.     CHECK(hugoOps.pkReadRecord(pNdb, 3, 1, NdbOperation::LM_Exclusive) == 0);
  481.     CHECK(hugoOps.pkInsertRecord(pNdb, 1) == 0);
  482.     CHECK(hugoOps.pkReadRecord(pNdb, 4, 1, NdbOperation::LM_Exclusive) == 0);
  483.     CHECK(hugoOps.execute_Commit(pNdb, TryCommit) == 626);
  484.   }while(false);
  486.   hugoOps.closeTransaction(pNdb);
  488.   return result;
  489. }
  491. int runCommit_TryCommit630(NDBT_Context* ctx, NDBT_Step* step){
  492.   int result = NDBT_OK;
  493.   HugoOperations hugoOps(*ctx->getTab());
  494.   Ndb* pNdb = GETNDB(step);
  495.   
  496.   do{
  497.     // Commit transaction, TryCommit
  498.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  499.     CHECK(hugoOps.pkInsertRecord(pNdb, 1) == 0);
  500.     CHECK(hugoOps.execute_Commit(pNdb, TryCommit) == 630);
  501.   }while(false);
  502.   
  503.   hugoOps.closeTransaction(pNdb);
  504.   
  505.   return result;
  506. }
  508. int runCommit_CommitAsMuchAsPossible626(NDBT_Context* ctx, NDBT_Step* step){
  509.   int result = NDBT_OK;
  510.   HugoOperations hugoOps(*ctx->getTab());
  511.   Ndb* pNdb = GETNDB(step);
  513.   do{
  514.     // Commit transaction, CommitAsMuchAsPossible
  515.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  516.     CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0);
  517.     CHECK(hugoOps.execute_Commit(pNdb, CommitAsMuchAsPossible) == 626);
  518.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  520.     // Commit transaction, CommitAsMuchAsPossible
  521.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  522.     CHECK(hugoOps.pkReadRecord(pNdb, 2, 1, NdbOperation::LM_Exclusive) == 0);
  523.     CHECK(hugoOps.pkReadRecord(pNdb, 3, 1, NdbOperation::LM_Exclusive) == 0);
  524.     CHECK(hugoOps.pkInsertRecord(pNdb, 1) == 0);
  525.     CHECK(hugoOps.execute_Commit(pNdb, CommitAsMuchAsPossible) == 626);
  526.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  528.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  529.     CHECK(hugoOps.pkReadRecord(pNdb, 1) == 0);
  530.     CHECK(hugoOps.execute_Commit(pNdb) == 0);
  531.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  532.   } while(false);
  534.   hugoOps.closeTransaction(pNdb);
  536.   return result;
  537. }
  539. int runCommit_CommitAsMuchAsPossible630(NDBT_Context* ctx, NDBT_Step* step){
  540.   int result = NDBT_OK;
  541.   HugoOperations hugoOps(*ctx->getTab());
  542.   Ndb* pNdb = GETNDB(step);
  544.   do{
  545.     // Commit transaction, CommitAsMuchAsPossible
  546.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  547.     CHECK(hugoOps.pkInsertRecord(pNdb, 1) == 0);
  548.     CHECK(hugoOps.pkDeleteRecord(pNdb, 2) == 0);
  549.     CHECK(hugoOps.execute_Commit(pNdb, CommitAsMuchAsPossible) == 630);
  550.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  552.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  553.     CHECK(hugoOps.pkReadRecord(pNdb, 2) == 0);
  554.     CHECK(hugoOps.execute_Commit(pNdb) == 0);
  555.   } while(false);
  557.   hugoOps.closeTransaction(pNdb);
  558.   
  559.   return result;
  560. }
  562. int runNoCommit626(NDBT_Context* ctx, NDBT_Step* step){
  563.   int result = NDBT_OK;
  564.   HugoOperations hugoOps(*ctx->getTab());
  565.   Ndb* pNdb = GETNDB(step);
  567.   do{
  568.     // No commit transaction, readTuple
  569.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  570.     CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Read) == 0);
  571.     CHECK(hugoOps.execute_NoCommit(pNdb) == 626);
  572.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  574.     // No commit transaction, readTupleExcluive
  575.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  576.     CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0);
  577.     CHECK(hugoOps.execute_NoCommit(pNdb) == 626);
  578.   }while(false);
  580.   hugoOps.closeTransaction(pNdb);
  581.   
  582.   return result;
  583. }
  585. int runNoCommit630(NDBT_Context* ctx, NDBT_Step* step){
  586.   int result = NDBT_OK;
  587.   HugoOperations hugoOps(*ctx->getTab());
  588.   Ndb* pNdb = GETNDB(step);
  590.   do{
  591.     // No commit transaction
  592.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  593.     CHECK(hugoOps.pkInsertRecord(pNdb, 1) == 0);
  594.     CHECK(hugoOps.execute_NoCommit(pNdb) == 630);
  595.   }while(false);
  597.   hugoOps.closeTransaction(pNdb);
  598.   
  599.   return result;
  600. }
  602. int runNoCommitRollback626(NDBT_Context* ctx, NDBT_Step* step){
  603.   int result = NDBT_OK;
  604.   HugoOperations hugoOps(*ctx->getTab());
  605.   Ndb* pNdb = GETNDB(step);
  607.   do{
  608.     // No commit transaction, rollback
  609.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  610.     CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0);
  611.     CHECK(hugoOps.execute_NoCommit(pNdb) == 626);
  612.     CHECK(hugoOps.execute_Rollback(pNdb) == 0);
  613.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  615.     // No commit transaction, rollback
  616.     // Multiple operations
  617.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  618.     CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0);
  619.     CHECK(hugoOps.pkReadRecord(pNdb, 2, 1, NdbOperation::LM_Exclusive) == 0);
  620.     CHECK(hugoOps.pkReadRecord(pNdb, 3, 1, NdbOperation::LM_Exclusive) == 0);
  621.     CHECK(hugoOps.pkReadRecord(pNdb, 4, 1, NdbOperation::LM_Exclusive) == 0);
  622.     CHECK(hugoOps.execute_NoCommit(pNdb) == 626);
  623.     CHECK(hugoOps.execute_Rollback(pNdb) == 0);
  624.   }while(false);
  626.   hugoOps.closeTransaction(pNdb);
  627.   
  628.   return result;
  629. }
  631. int runNoCommitRollback630(NDBT_Context* ctx, NDBT_Step* step){
  632.   int result = NDBT_OK;
  633.   HugoOperations hugoOps(*ctx->getTab());
  634.   Ndb* pNdb = GETNDB(step);
  636.   do{
  637.     // No commit transaction, rollback
  638.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  639.     CHECK(hugoOps.pkInsertRecord(pNdb, 1) == 0);
  640.     CHECK(hugoOps.execute_NoCommit(pNdb) == 630);
  641.     CHECK(hugoOps.execute_Rollback(pNdb) == 0);
  642.   }while(false);
  644.   hugoOps.closeTransaction(pNdb);
  646.   return result;
  647. }
  650. int runNoCommitAndClose(NDBT_Context* ctx, NDBT_Step* step){
  651.   int i, result = NDBT_OK;
  652.   HugoOperations hugoOps(*ctx->getTab());
  653.   Ndb* pNdb = GETNDB(step);
  655.   do{
  656.     // Read 
  657.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  658.     for (i = 0; i < 10; i++)
  659.       CHECK(hugoOps.pkReadRecord(pNdb, i, 1, NdbOperation::LM_Exclusive) == 0);
  660.     CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  661.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  662.   
  663.     // Update
  664.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  665.     for (i = 0; i < 10; i++)
  666.       CHECK(hugoOps.pkUpdateRecord(pNdb, i) == 0);
  667.     CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  668.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  669.   
  670.     // Delete
  671.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  672.     for (i = 0; i < 10; i++)
  673.       CHECK(hugoOps.pkDeleteRecord(pNdb, i) == 0);
  674.     CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  675.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  677.     // Try to insert, record should already exist
  678.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  679.     for (i = 0; i < 10; i++)
  680.       CHECK(hugoOps.pkInsertRecord(pNdb, i) == 0);
  681.     CHECK(hugoOps.execute_Commit(pNdb) == 630);
  682.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  684.   }while(false);
  686.   hugoOps.closeTransaction(pNdb);
  688.   return result;
  689. }
  693. int runCheckRollbackDelete(NDBT_Context* ctx, NDBT_Step* step){
  694.   int result = NDBT_OK;
  695.   HugoOperations hugoOps(*ctx->getTab());
  696.   Ndb* pNdb = GETNDB(step);
  698.   do{
  700.     // Read value and save it for later
  701.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  702.     CHECK(hugoOps.pkReadRecord(pNdb, 5) == 0);
  703.     CHECK(hugoOps.execute_Commit(pNdb) == 0);
  704.     CHECK(hugoOps.saveCopyOfRecord() == NDBT_OK);
  705.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  707.     // Delete record 5
  708.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  709.     CHECK(hugoOps.pkDeleteRecord(pNdb, 5) == 0);
  710.     CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  712.     // Check record is deleted
  713.     CHECK(hugoOps.pkReadRecord(pNdb, 5, 1, NdbOperation::LM_Exclusive) == 0);
  714.     CHECK(hugoOps.execute_NoCommit(pNdb) == 626);
  715.     CHECK(hugoOps.execute_Rollback(pNdb) == 0);
  717.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  719.     // Check record is not deleted
  720.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  721.     CHECK(hugoOps.pkReadRecord(pNdb, 5, 1, NdbOperation::LM_Exclusive) == 0);
  722.     CHECK(hugoOps.execute_Commit(pNdb) == 0);
  723.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  725.     // Check record is back to original value
  726.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  727.     CHECK(hugoOps.pkReadRecord(pNdb, 5, 1, NdbOperation::LM_Exclusive) == 0);
  728.     CHECK(hugoOps.execute_Commit(pNdb) == 0);
  729.     CHECK(hugoOps.compareRecordToCopy() == NDBT_OK);
  732.   }while(false);
  734.   hugoOps.closeTransaction(pNdb);
  736.   return result;
  737. }
  739. int runCheckRollbackUpdate(NDBT_Context* ctx, NDBT_Step* step){
  740.   int result = NDBT_OK;
  741.   HugoOperations hugoOps(*ctx->getTab());
  742.   Ndb* pNdb = GETNDB(step);
  743.   int numRecords = 5;
  744.   do{
  745.     
  746.     // Read value and save it for later
  747.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  748.     CHECK(hugoOps.pkReadRecord(pNdb, 1, numRecords) == 0);
  749.     CHECK(hugoOps.execute_Commit(pNdb) == 0);
  750.     CHECK(hugoOps.verifyUpdatesValue(0) == NDBT_OK); // Update value 0
  751.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  753.     // Update  record 5
  754.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  755.     CHECK(hugoOps.pkUpdateRecord(pNdb, 1, numRecords, 5) == 0);// Updates value 5
  756.     CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  757.   
  758.     // Check record is updated
  759.     CHECK(hugoOps.pkReadRecord(pNdb, 1, numRecords, NdbOperation::LM_Exclusive) == 0);
  760.     CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  761.     CHECK(hugoOps.verifyUpdatesValue(5) == NDBT_OK); // Updates value 5
  762.     CHECK(hugoOps.execute_Rollback(pNdb) == 0);
  764.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  766.     // Check record is back to original value
  767.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  768.     CHECK(hugoOps.pkReadRecord(pNdb, 1, numRecords, NdbOperation::LM_Exclusive) == 0);
  769.     CHECK(hugoOps.execute_Commit(pNdb) == 0);
  770.     CHECK(hugoOps.verifyUpdatesValue(0) == NDBT_OK); // Updates value 0
  772.   }while(false);
  774.   hugoOps.closeTransaction(pNdb);
  776.   return result;
  777. }
  779. int runCheckRollbackDeleteMultiple(NDBT_Context* ctx, NDBT_Step* step){
  780.   int result = NDBT_OK;
  781.   HugoOperations hugoOps(*ctx->getTab());
  782.   Ndb* pNdb = GETNDB(step);
  784.   do{
  785.     // Read value and save it for later
  786.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  787.     CHECK(hugoOps.pkReadRecord(pNdb, 5, 10) == 0);
  788.     CHECK(hugoOps.execute_Commit(pNdb) == 0);
  789.     CHECK(hugoOps.verifyUpdatesValue(0) == NDBT_OK);
  790.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  791.     
  792.     Uint32 updatesValue = 0;
  793.     Uint32 j;
  794.     for(Uint32 i = 0; i<1; i++){
  795.       // Read  record 5 - 10
  796.       CHECK(hugoOps.startTransaction(pNdb) == 0);  
  797.       CHECK(hugoOps.pkReadRecord(pNdb, 5, 10, NdbOperation::LM_Exclusive) == 0);
  798.       CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  799.       
  800.       for(j = 0; j<10; j++){
  801. // Update  record 5 - 10
  802. updatesValue++;
  803. CHECK(hugoOps.pkUpdateRecord(pNdb, 5, 10, updatesValue) == 0);
  804. CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  806. CHECK(hugoOps.pkReadRecord(pNdb, 5, 10, NdbOperation::LM_Exclusive) == 0);
  807. CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  808. CHECK(hugoOps.verifyUpdatesValue(updatesValue) == 0);
  809.       }      
  810.       
  811.       for(j = 0; j<10; j++){
  812. // Delete record 5 - 10 times
  813. CHECK(hugoOps.pkDeleteRecord(pNdb, 5, 10) == 0);
  814. CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  816. #if 0
  817. // Check records are deleted
  818. CHECK(hugoOps.pkReadRecord(pNdb, 5, 10, NdbOperation::LM_Exclusive) == 0);
  819. CHECK(hugoOps.execute_NoCommit(pNdb) == 626);
  820. #endif
  822. updatesValue++;
  823. CHECK(hugoOps.pkInsertRecord(pNdb, 5, 10, updatesValue) == 0);
  824. CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  826. CHECK(hugoOps.pkReadRecord(pNdb, 5, 10, NdbOperation::LM_Exclusive) == 0);
  827. CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  828. CHECK(hugoOps.verifyUpdatesValue(updatesValue) == 0);
  829.       }
  831.       CHECK(hugoOps.pkDeleteRecord(pNdb, 5, 10) == 0);
  832.       CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  834.       // Check records are deleted
  835.       CHECK(hugoOps.pkReadRecord(pNdb, 5, 10, NdbOperation::LM_Exclusive) == 0);
  836.       CHECK(hugoOps.execute_NoCommit(pNdb) == 626);
  837.       CHECK(hugoOps.execute_Rollback(pNdb) == 0);
  838.       
  839.       CHECK(hugoOps.closeTransaction(pNdb) == 0);
  840.     }
  841.     
  842.     // Check records are not deleted
  843.     // after rollback
  844.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  845.     CHECK(hugoOps.pkReadRecord(pNdb, 5, 10, NdbOperation::LM_Exclusive) == 0);
  846.     CHECK(hugoOps.execute_Commit(pNdb) == 0);
  847.     CHECK(hugoOps.verifyUpdatesValue(0) == NDBT_OK);
  848.     
  849.   }while(false);
  851.   hugoOps.closeTransaction(pNdb);
  853.   return result;
  854. }
  857. int runCheckImplicitRollbackDelete(NDBT_Context* ctx, NDBT_Step* step){
  858.   int result = NDBT_OK;
  859.   HugoOperations hugoOps(*ctx->getTab());
  860.   Ndb* pNdb = GETNDB(step);
  862.   do{
  863.     // Read  record 5
  864.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  865.     CHECK(hugoOps.pkReadRecord(pNdb, 5, 1, NdbOperation::LM_Exclusive) == 0);
  866.     CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  867.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  868.     
  869.     // Update  record 5
  870.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  871.     CHECK(hugoOps.pkUpdateRecord(pNdb, 5) == 0);
  872.     CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  873.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  874.   
  875.     // Delete record 5
  876.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  877.     CHECK(hugoOps.pkDeleteRecord(pNdb, 5) == 0);
  878.     CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  879.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  881.     // Check record is not deleted
  882.     // Close transaction should have rollbacked
  883.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  884.     CHECK(hugoOps.pkReadRecord(pNdb, 5, 1, NdbOperation::LM_Exclusive) == 0);
  885.     CHECK(hugoOps.execute_Commit(pNdb) == 0);
  886.   }while(false);
  888.   hugoOps.closeTransaction(pNdb);
  890.   return result;
  891. }
  893. int runCheckCommitDelete(NDBT_Context* ctx, NDBT_Step* step){
  894.   int result = NDBT_OK;
  895.   HugoOperations hugoOps(*ctx->getTab());
  896.   Ndb* pNdb = GETNDB(step);
  898.   do{
  899.     // Read  10 records
  900.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  901.     CHECK(hugoOps.pkReadRecord(pNdb, 5, 10, NdbOperation::LM_Exclusive) == 0);
  902.     CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  903.   
  904.     // Update 10 records
  905.     CHECK(hugoOps.pkUpdateRecord(pNdb, 5, 10) == 0);
  906.     CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  907.   
  908.     // Delete 10 records
  909.     CHECK(hugoOps.pkDeleteRecord(pNdb, 5, 10) == 0);
  910.     CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  912.     CHECK(hugoOps.execute_Commit(pNdb) == 0);
  913.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  915.     // Check record's are deleted
  916.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  917.     CHECK(hugoOps.pkReadRecord(pNdb, 5, 10, NdbOperation::LM_Exclusive) == 0);
  918.     CHECK(hugoOps.execute_Commit(pNdb) == 626);
  920.   }while(false);
  922.   hugoOps.closeTransaction(pNdb);
  924.   return result;
  925. }
  927. int runRollbackNothing(NDBT_Context* ctx, NDBT_Step* step){
  928.   int result = NDBT_OK;
  929.   HugoOperations hugoOps(*ctx->getTab());
  930.   Ndb* pNdb = GETNDB(step);
  932.   do{
  933.     // Delete record 5 - 15
  934.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  935.     CHECK(hugoOps.pkDeleteRecord(pNdb, 5, 10) == 0);
  936.     // Rollback 
  937.     CHECK(hugoOps.execute_Rollback(pNdb) == 0);
  938.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  940.     // Check records are not deleted
  941.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  942.     CHECK(hugoOps.pkReadRecord(pNdb, 5, 10, NdbOperation::LM_Exclusive) == 0);
  943.     CHECK(hugoOps.execute_Commit(pNdb) == 0);
  944.     CHECK(hugoOps.closeTransaction(pNdb) == 0);  
  946.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  947.     CHECK(hugoOps.execute_Rollback(pNdb) == 0);
  949.   }while(false);
  951.   hugoOps.closeTransaction(pNdb);
  953.   return result;
  954. }
  956. int runMassiveRollback(NDBT_Context* ctx, NDBT_Step* step){
  958.   NdbRestarter restarter;
  959.   const int records = 4 * restarter.getNumDbNodes();
  961.   HugoTransactions hugoTrans(*ctx->getTab());
  962.   if (hugoTrans.loadTable(GETNDB(step), records) != 0){
  963.     return NDBT_FAILED;
  964.   }
  965.   
  966.   int result = NDBT_OK;
  967.   HugoOperations hugoOps(*ctx->getTab());
  968.   Ndb* pNdb = GETNDB(step);
  970.   const Uint32 OPS_PER_TRANS = 256;
  971.   const Uint32 OPS_TOTAL = 4096;
  973.   for(int row = 0; row < records; row++){
  974.     int res;
  975.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  976.     for(Uint32 i = 0; i<OPS_TOTAL; i += OPS_PER_TRANS){
  977.       for(Uint32 j = 0; j<OPS_PER_TRANS; j++){
  978. CHECK(hugoOps.pkUpdateRecord(pNdb, row, 1, i) == 0);
  979.       }
  980.       g_info << "Performed " << (i+OPS_PER_TRANS) << " updates on row: " << row
  981.      << endl;
  982.       if(result != NDBT_OK){
  983. break;
  984.       }
  985.       res = hugoOps.execute_NoCommit(pNdb);
  986.       if(res != 0){
  987. NdbError err = pNdb->getNdbError(res);
  988. CHECK(err.classification == NdbError::TimeoutExpired);
  989. break;
  990.       }
  991.     }
  992.     if(result != NDBT_OK){
  993.       break;
  994.     }
  995.     g_info << "executeRollback" << endl;
  996.     CHECK(hugoOps.execute_Rollback(pNdb) == 0);
  997.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  998.   }
  999.   
  1000.   hugoOps.closeTransaction(pNdb);
  1001.   return result;
  1002. }
  1004. int
  1005. runMassiveRollback2(NDBT_Context* ctx, NDBT_Step* step){
  1007.   HugoTransactions hugoTrans(*ctx->getTab());
  1008.   if (hugoTrans.loadTable(GETNDB(step), 1) != 0){
  1009.     return NDBT_FAILED;
  1010.   }
  1012.   int result = NDBT_OK;
  1013.   HugoOperations hugoOps(*ctx->getTab());
  1014.   Ndb* pNdb = GETNDB(step);
  1016.   const Uint32 OPS_TOTAL = 4096;
  1017.   const Uint32 LOOPS = 10;
  1018.   
  1019.   for(Uint32 loop = 0; loop<LOOPS; loop++){
  1020.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  1021.     for(Uint32 i = 0; i<OPS_TOTAL-1; i ++){
  1022.       if((i & 1) == 0){
  1023. CHECK(hugoOps.pkUpdateRecord(pNdb, 0, 1, loop) == 0);
  1024.       } else {
  1025. CHECK(hugoOps.pkUpdateRecord(pNdb, 1, 1, loop) == 0);
  1026.       }
  1027.     }
  1028.     CHECK(hugoOps.execute_Commit(pNdb) == 626);
  1029.     CHECK(hugoOps.execute_Rollback(pNdb) == 0);
  1030.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  1031.   }
  1032.   
  1033.   hugoOps.closeTransaction(pNdb);
  1034.   return result;
  1035. }
  1038. NDBT_TESTSUITE(testBasic);
  1039. TESTCASE("PkInsert", 
  1040.  "Verify that we can insert and delete from this table using PK"
  1041.  "NOTE! No errors are allowed!" ){
  1042.   INITIALIZER(runInsert);
  1043.   VERIFIER(runVerifyInsert);
  1044. }
  1045. TESTCASE("PkRead", 
  1046.    "Verify that we can insert, read and delete from this table using PK"){
  1047.   INITIALIZER(runLoadTable);
  1048.   STEP(runPkRead);
  1049.   FINALIZER(runClearTable);
  1050. }
  1051. TESTCASE("PkDirtyRead", 
  1052.  "Verify that we can insert, dirty read and delete from this table using PK"){
  1053.   INITIALIZER(runLoadTable);
  1054.   STEP(runPkDirtyRead);
  1055.   FINALIZER(runClearTable);
  1056. }
  1057. TESTCASE("PkUpdate", 
  1058.    "Verify that we can insert, update and delete from this table using PK"){
  1059.   INITIALIZER(runLoadTable);
  1060.   STEP(runPkUpdate);
  1061.   FINALIZER(runClearTable);
  1062. }
  1063. TESTCASE("PkDelete", 
  1064.  "Verify that we can delete from this table using PK"){
  1065.   INITIALIZER(runLoadTable);
  1066.   STEP(runPkDelete);
  1067.   FINALIZER(runClearTable);
  1068. }
  1069. TESTCASE("UpdateAndRead", 
  1070.  "Verify that we can read and update at the same time"){
  1071.   INITIALIZER(runLoadTable);
  1072.   STEP(runPkRead);
  1073.   STEP(runPkRead);
  1074.   STEP(runPkRead);
  1075.   STEP(runPkUpdate);  
  1076.   STEP(runPkUpdate);
  1077.   STEP(runPkUpdate);
  1078.   FINALIZER(runClearTable);
  1079. }
  1080. TESTCASE("PkReadAndLocker", 
  1081.  "Verify that we can read although there are "
  1082.  " a number of 1 second locks in the table"){
  1083.   INITIALIZER(runLoadTable);
  1084.   STEP(runPkReadUntilStopped);
  1085.   STEP(runLocker);
  1086.   FINALIZER(runClearTable);
  1087. }
  1088. TESTCASE("PkReadAndLocker2", 
  1089.  "Verify that we can read and update although there are "
  1090.  " a number of 1 second locks in the table"){
  1091.   INITIALIZER(runLoadTable);
  1092.   STEP(runPkReadUntilStopped);
  1093.   STEP(runPkReadUntilStopped);
  1094.   STEP(runPkReadUntilStopped);
  1095.   STEP(runPkReadUntilStopped);
  1096.   STEP(runPkReadUntilStopped);
  1097.   STEP(runPkReadUntilStopped);
  1098.   STEP(runLocker);
  1099.   FINALIZER(runClearTable);
  1100. }
  1101. TESTCASE("PkReadUpdateAndLocker", 
  1102.  "Verify that we can read and update although there are "
  1103.  " a number of 1 second locks in the table"){
  1104.   INITIALIZER(runLoadTable);
  1105.   STEP(runPkReadUntilStopped);
  1106.   STEP(runPkReadUntilStopped);
  1107.   STEP(runPkUpdateUntilStopped);
  1108.   STEP(runPkUpdateUntilStopped);
  1109.   STEP(runLocker);
  1110.   FINALIZER(runClearTable);
  1111. }
  1112. TESTCASE("ReadWithLocksAndInserts", 
  1113.  "TR457: This test is added to verify that an insert of a records "
  1114.  "that is already in the database does not delete the record"){  
  1115.   INITIALIZER(runLoadTable);
  1116.   STEP(runPkReadUntilStopped);
  1117.   STEP(runPkReadUntilStopped);
  1118.   STEP(runLocker);
  1119.   STEP(runInsertUntilStopped);
  1120.   FINALIZER(runClearTable);
  1121. }
  1122. TESTCASE("PkInsertTwice", 
  1123.  "Verify that we can't insert an already inserted record."
  1124.  "Error should be returned" ){
  1125.   INITIALIZER(runLoadTable);
  1126.   STEP(runInsertTwice);
  1127.   FINALIZER(runClearTable);
  1128. }
  1129. TESTCASE("NoCommitSleep", 
  1130.  "Verify what happens when a NoCommit transaction is aborted by "
  1131.  "NDB because the application is sleeping" ){
  1132.   INITIALIZER(runLoadTable);
  1133.   INITIALIZER(runNoCommitSleep);
  1134.   FINALIZER(runClearTable2);
  1135. }
  1136. TESTCASE("Commit626", 
  1137.  "Verify what happens when a Commit transaction is aborted by "
  1138.  "NDB because the record does no exist" ){
  1139.   INITIALIZER(runClearTable2);
  1140.   INITIALIZER(runCommit626);
  1141.   FINALIZER(runClearTable2);
  1142. }
  1143. TESTCASE("CommitTry626", 
  1144.  "Verify what happens when a Commit(TryCommit) n"
  1145.  "transaction is aborted by "
  1146.  "NDB because the record does no exist" ){
  1147.   INITIALIZER(runClearTable2);
  1148.   INITIALIZER(runCommit_TryCommit626);
  1149.   FINALIZER(runClearTable2);
  1150. }
  1151. TESTCASE("CommitAsMuch626", 
  1152.  "Verify what happens when a Commit(CommitAsMuchAsPossible) n"
  1153.  "transaction is aborted byn"
  1154.  "NDB because the record does no exist" ){
  1155.   INITIALIZER(runClearTable2);
  1156.   INITIALIZER(runCommit_CommitAsMuchAsPossible626);
  1157.   FINALIZER(runClearTable2);
  1158. }
  1159. TESTCASE("NoCommit626", 
  1160.  "Verify what happens when a NoCommit transaction is aborted by "
  1161.  "NDB because the record does no exist" ){
  1162.   INITIALIZER(runClearTable2);
  1163.   INITIALIZER(runNoCommit626);
  1164.   FINALIZER(runClearTable2);
  1165. }
  1166. TESTCASE("NoCommitRollback626", 
  1167.  "Verify what happens when a NoCommit transaction is aborted by "
  1168.  "NDB because the record does no exist and then we try to rollbackn"
  1169.  "the transaction" ){
  1170.   INITIALIZER(runClearTable2);
  1171.   INITIALIZER(runNoCommitRollback626);
  1172.   FINALIZER(runClearTable2);
  1173. }
  1174. TESTCASE("Commit630", 
  1175.  "Verify what happens when a Commit transaction is aborted by "
  1176.  "NDB because the record already exist" ){
  1177.   INITIALIZER(runLoadTable);
  1178.   INITIALIZER(runCommit630);
  1179.   FINALIZER(runClearTable2);
  1180. }
  1181. TESTCASE("CommitTry630", 
  1182.  "Verify what happens when a Commit(TryCommit) n"
  1183.  "transaction is aborted by "
  1184.  "NDB because the record already exist" ){
  1185.   INITIALIZER(runLoadTable);
  1186.   INITIALIZER(runCommit_TryCommit630);
  1187.   FINALIZER(runClearTable2);
  1188. }
  1189. TESTCASE("CommitAsMuch630", 
  1190.  "Verify what happens when a Commit(CommitAsMuchAsPossible) n"
  1191.  "transaction is aborted byn"
  1192.  "NDB because the record already exist" ){
  1193.   INITIALIZER(runLoadTable);
  1194.   INITIALIZER(runCommit_CommitAsMuchAsPossible630);
  1195.   FINALIZER(runClearTable2);
  1196. }
  1197. TESTCASE("NoCommit630", 
  1198.  "Verify what happens when a NoCommit transaction is aborted by "
  1199.  "NDB because the record already exist" ){
  1200.   INITIALIZER(runLoadTable);
  1201.   INITIALIZER(runNoCommit630);
  1202.   FINALIZER(runClearTable2);
  1203. }
  1204. TESTCASE("NoCommitRollback630", 
  1205.  "Verify what happens when a NoCommit transaction is aborted by "
  1206.  "NDB because the record already exist and then we try to rollbackn"
  1207.  "the transaction" ){
  1208.   INITIALIZER(runLoadTable);
  1209.   INITIALIZER(runNoCommitRollback630);
  1210.   FINALIZER(runClearTable2);
  1211. }
  1212. TESTCASE("NoCommitAndClose", 
  1213.  "Verify what happens when a NoCommit transaction is closed "
  1214.  "without rolling back the transaction " ){
  1215.   INITIALIZER(runLoadTable);
  1216.   INITIALIZER(runNoCommitAndClose);
  1217.   FINALIZER(runClearTable2);
  1218. }
  1219. TESTCASE("RollbackDelete", 
  1220.  "Test rollback of a no committed delete"){
  1221.   INITIALIZER(runLoadTable);
  1222.   INITIALIZER(runCheckRollbackDelete);
  1223.   FINALIZER(runClearTable2);
  1224. }
  1225. TESTCASE("RollbackUpdate", 
  1226.  "Test rollback of a no committed update"){
  1227.   INITIALIZER(runLoadTable);
  1228.   INITIALIZER(runCheckRollbackUpdate);
  1229.   FINALIZER(runClearTable2);
  1230. }
  1231. TESTCASE("RollbackDeleteMultiple", 
  1232.  "Test rollback of 10 non committed delete"){
  1233.   INITIALIZER(runLoadTable);
  1234.   INITIALIZER(runCheckRollbackDeleteMultiple);
  1235.   FINALIZER(runClearTable2);
  1236. }
  1237. TESTCASE("ImplicitRollbackDelete", 
  1238.  "Test close transaction after a no commited deleten"
  1239.  "this would give an implicit rollback of the deleten"){
  1240.   INITIALIZER(runLoadTable);
  1241.   INITIALIZER(runCheckImplicitRollbackDelete);
  1242.   FINALIZER(runClearTable2);
  1243. }
  1244. TESTCASE("CommitDelete", 
  1245.  "Test close transaction after a no commited deleten"
  1246.  "this would give an implicit rollback of the deleten"){
  1247.   INITIALIZER(runLoadTable);
  1248.   INITIALIZER(runCheckCommitDelete);
  1249.   FINALIZER(runClearTable2);
  1250. }
  1251. TESTCASE("RollbackNothing", 
  1252.  "Test rollback of nothing"){
  1253.   INITIALIZER(runLoadTable);
  1254.   INITIALIZER(runRollbackNothing);
  1255.   FINALIZER(runClearTable2);
  1256. }
  1257. TESTCASE("MassiveRollback", 
  1258.  "Test rollback of 4096 operations"){
  1259.   INITIALIZER(runClearTable2);
  1260.   INITIALIZER(runMassiveRollback);
  1261.   FINALIZER(runClearTable2);
  1262. }
  1263. TESTCASE("MassiveRollback2", 
  1264.  "Test rollback of 4096 operations"){
  1265.   INITIALIZER(runClearTable2);
  1266.   INITIALIZER(runMassiveRollback2);
  1267.   FINALIZER(runClearTable2);
  1268. }
  1269. TESTCASE("MassiveTransaction",
  1270.          "Test very large insert transaction"){
  1271.   INITIALIZER(runLoadTable2);
  1272.   FINALIZER(runClearTable2);
  1273. }
  1274. TESTCASE("Fill", 
  1275.  "Verify what happens when we fill the db" ){
  1276.   INITIALIZER(runFillTable);
  1277.   INITIALIZER(runPkRead);
  1278.   FINALIZER(runClearTable2);
  1279. }
  1280. NDBT_TESTSUITE_END(testBasic);
  1282. #if 0
  1283. TESTCASE("ReadConsistency",
  1284.  "Check that a read within a transaction returns the " 
  1285.  "same result no matter"){
  1286.   STEP(runInsertOne);
  1287.   STEP(runReadOne);
  1288.   FINALIZER(runClearTable2);
  1289. }
  1290. #endif
  1292. int main(int argc, const char** argv){
  1293.   ndb_init();
  1294.   return testBasic.execute(argc, argv);
  1295. }