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

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

MySQL数据库

开发平台：

Visual C++

testOperations.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"
  22. struct OperationTestCase {
  23.   const char * name;
  24.   bool preCond; // start transaction | insert | commit
  26.   // start transaction
  27.   const char * op1;
  28.   const int res1;
  29.   const int val1;
  31.   // no commit
  33.   const char * op2;
  34.   const int res2;
  35.   const int val2;
  36.   // Commit
  38.   // start transaction
  39.   // op3 = READ
  40.   const int res3;
  41.   const int val3;
  42.   // commit transaction
  43. };
  45. OperationTestCase matrix[] = {
  46.   { "ReadRead",         true, "READ",  0, 0, "READ",      0, 0,   0, 0 },
  47.   { "ReadReadEx",       true, "READ",  0, 0, "READ-EX",   0, 0,   0, 0 },
  48.   { "ReadSimpleRead",   true, "READ",  0, 0, "S-READ",    0, 0,   0, 0 },
  49.   { "ReadDirtyRead",    true, "READ",  0, 0, "D-READ",    0, 0,   0, 0 },
  50.   { "ReadInsert",       true, "READ",  0, 0, "INSERT",  630, 1,   0, 0 },
  51.   { "ReadUpdate",       true, "READ",  0, 0, "UPDATE",    0, 1,   0, 1 },
  52.   { "ReadDelete",       true, "READ",  0, 0, "DELETE",    0, 0, 626, 0 },
  54.   { "FReadRead",       false, "READ", 626, 0, "READ",    626, 0, 626, 0 },
  55.   { "FReadReadEx",     false, "READ", 626, 0, "READ-EX", 626, 0, 626, 0 },
  56.   { "FReadSimpleRead", false, "READ", 626, 0, "S-READ",  626, 0, 626, 0 },
  57.   { "FReadDirtyRead",  false, "READ", 626, 0, "D-READ",  626, 0, 626, 0 },
  58.   { "FReadInsert",     false, "READ", 626, 0, "INSERT",    0, 1,   0, 1 },
  59.   { "FReadUpdate",     false, "READ", 626, 0, "UPDATE",  626, 0, 626, 0 },
  60.   { "FReadDelete",     false, "READ", 626, 0, "DELETE",  626, 0, 626, 0 },
  62.   { "ReadExRead",       true, "READ-EX", 0, 0, "READ",      0, 0,   0, 0 },
  63.   { "ReadExReadEx",     true, "READ-EX", 0, 0, "READ-EX",   0, 0,   0, 0 },
  64.   { "ReadExSimpleRead", true, "READ-EX", 0, 0, "S-READ",    0, 0,   0, 0 },
  65.   { "ReadExDirtyRead",  true, "READ-EX", 0, 0, "D-READ",    0, 0,   0, 0 },
  66.   { "ReadExInsert",     true, "READ-EX", 0, 0, "INSERT",  630, 1,   0, 0 },
  67.   { "ReadExUpdate",     true, "READ-EX", 0, 0, "UPDATE",    0, 1,   0, 1 },
  68.   { "ReadExDelete",     true, "READ-EX", 0, 0, "DELETE",    0, 0, 626, 0 },
  70.   { "InsertRead",      false, "INSERT", 0, 0, "READ",      0, 0,   0, 0 },
  71.   { "InsertReadEx",    false, "INSERT", 0, 0, "READ-EX",   0, 0,   0, 0 },
  72.   { "InsertSimpleRead",false, "INSERT", 0, 0, "S-READ",    0, 0,   0, 0 },
  73.   { "InsertDirtyRead", false, "INSERT", 0, 0, "D-READ",    0, 0,   0, 0 },
  74.   { "InsertInsert",    false, "INSERT", 0, 0, "INSERT",  630, 0, 626, 0 },
  75.   { "InsertUpdate",    false, "INSERT", 0, 0, "UPDATE",    0, 1,   0, 1 },
  76.   { "InsertDelete",    false, "INSERT", 0, 0, "DELETE",    0, 0, 626, 0 },
  78.   { "UpdateRead",       true, "UPDATE", 0, 1, "READ",      0, 1,   0, 1 },
  79.   { "UpdateReadEx",     true, "UPDATE", 0, 1, "READ-EX",   0, 1,   0, 1 },
  80.   { "UpdateSimpleRead", true, "UPDATE", 0, 1, "S-READ",    0, 1,   0, 1 },
  81.   { "UpdateDirtyRead",  true, "UPDATE", 0, 1, "D-READ",    0, 1,   0, 1 },
  82.   { "UpdateInsert",     true, "UPDATE", 0, 1, "INSERT",  630, 0,   0, 0 },
  83.   { "UpdateUpdate",     true, "UPDATE", 0, 1, "UPDATE",    0, 2,   0, 2 },
  84.   { "UpdateDelete",     true, "UPDATE", 0, 1, "DELETE",    0, 0, 626, 0 },
  86.   { "DeleteRead",       true, "DELETE", 0, 0, "READ",    626, 0,   0, 0 },
  87.   { "DeleteReadEx",     true, "DELETE", 0, 0, "READ-EX", 626, 0,   0, 0 },
  88.   { "DeleteSimpleRead", true, "DELETE", 0, 0, "S-READ",  626, 0,   0, 0 },
  89.   { "DeleteDirtyRead",  true, "DELETE", 0, 0, "D-READ",  626, 0, 626, 0 },
  90.   { "DeleteInsert",     true, "DELETE", 0, 0, "INSERT",    0, 1,   0, 1 },
  91.   { "DeleteUpdate",     true, "DELETE", 0, 0, "UPDATE",  626, 1,   0, 0 },
  92.   { "DeleteDelete",     true, "DELETE", 0, 0, "DELETE",  626, 0,   0, 0 }
  93. };
  95. #define CHECK(b) if (!(b)) { 
  96.   g_err  << "ERR: "<< step->getName() 
  97.          << " failed on line " << __LINE__ << endl; 
  98.   result = NDBT_FAILED; 
  99.   break; }
  101. #define C3(b)  if (!(b)) { 
  102.   g_err  << "ERR: "<< step->getName() 
  103.          << " failed on line " << __LINE__ << endl; 
  104.   abort(); return NDBT_FAILED; }
  106. #define C3(b)  if (!(b)) { 
  107.   g_err  << "ERR: failed on line " << __LINE__ << endl; 
  108.   return NDBT_FAILED; }
  110. int
  111. runOp(HugoOperations & hugoOps,
  112.       Ndb * pNdb,
  113.       const char * op,
  114.       int value){
  116. #define C2(x, y) { int r = (x); int s = (y); if(r != s) {
  117.   g_err  << "ERR: failed on line " << __LINE__ << ": " 
  118.      << r << " != " << s << endl; 
  119.   return NDBT_FAILED; }}
  120.   
  121.   if(strcmp(op, "READ") == 0){
  122.     C2(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Read), 0);
  123.   } else if(strcmp(op, "READ-EX") == 0){
  124.     C2(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive), 0);      
  125.   } else if(strcmp(op, "S-READ") == 0){
  126.     C2(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Read), 0);
  127.   } else if(strcmp(op, "D-READ") == 0){
  128.     C2(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_CommittedRead), 0);
  129.   } else if(strcmp(op, "INSERT") == 0){
  130.     C2(hugoOps.pkInsertRecord(pNdb, 1, 1, value), 0);
  131.   } else if(strcmp(op, "UPDATE") == 0){
  132.     C2(hugoOps.pkUpdateRecord(pNdb, 1, 1, value), 0);
  133.   } else if(strcmp(op, "DELETE") == 0){
  134.     C2(hugoOps.pkDeleteRecord(pNdb, 1, 1), 0);
  135.   } else {
  136.     g_err << __FILE__ << " - " << __LINE__ 
  137.   << ": Unknown operation" << op << endl;
  138.     return NDBT_FAILED;
  139.   }
  141.   return NDBT_OK;
  142. }
  144. int
  145. checkVal(HugoOperations & hugoOps,
  146.  const char * op,
  147.  int value,
  148.  int result){
  149.   if(result != 0)
  150.     return NDBT_OK;
  152.   if(strcmp(op, "READ") == 0){
  153.   } else if(strcmp(op, "READ-EX") == 0){
  154.   } else if(strcmp(op, "S-READ") == 0){
  155.   } else if(strcmp(op, "D-READ") == 0){
  156.   } else {
  157.     return NDBT_OK;
  158.   }
  159.   
  160.   return hugoOps.verifyUpdatesValue(value);
  161. }
  163. int 
  164. runTwoOperations(NDBT_Context* ctx, NDBT_Step* step){
  165.   int result = NDBT_OK;
  166.   HugoOperations hugoOps(*ctx->getTab());
  167.   Ndb* pNdb = GETNDB(step);
  168.   
  169.   const char * op1 = ctx->getProperty("op1", "NONE");
  170.   const int val1 = ctx->getProperty("val1", ~0);
  171.   const int res1 = ctx->getProperty("res1", ~0);
  172.   const char * op2 = ctx->getProperty("op2", "NONE");
  173.   const int res2 = ctx->getProperty("res2", ~0);
  174.   const int val2 = ctx->getProperty("val2", ~0);
  176.   const int res3 = ctx->getProperty("res3", ~0);
  177.   const int val3 = ctx->getProperty("val3", ~0);
  179.   do {
  180.     // Insert, read
  181.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  182.     CHECK(runOp(hugoOps, pNdb, op1, val1) == 0);
  183.     AbortOption oa = (res1 == 0) ? AbortOnError : AO_IgnoreError;
  184.     CHECK(hugoOps.execute_NoCommit(pNdb, oa) == res1);
  185.     CHECK(checkVal(hugoOps, op1, val1, res1) == 0);
  187.     ndbout_c("-- running op 2");
  189.     CHECK(runOp(hugoOps, pNdb, op2, val2) == 0);
  190.     CHECK(hugoOps.execute_Commit(pNdb) == res2);
  191.     CHECK(checkVal(hugoOps, op2, val2, res2) == 0);
  193.   } while(false);
  194.   hugoOps.closeTransaction(pNdb);
  196.   if(result != NDBT_OK)
  197.     return result;
  199.   do {
  200.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  201.     CHECK(runOp(hugoOps, pNdb, "READ", 0) == 0);
  202.     CHECK(hugoOps.execute_Commit(pNdb) == res3);
  203.     CHECK(checkVal(hugoOps, "READ", val3, res3) == 0);
  204.   } while(false);
  205.   hugoOps.closeTransaction(pNdb);
  207.   return result;
  208. }
  210. int 
  211. runInsertRecord(NDBT_Context* ctx, NDBT_Step* step){
  212.   int result = NDBT_OK;
  213.   HugoOperations hugoOps(*ctx->getTab());
  214.   Ndb* pNdb = GETNDB(step);
  215.   
  216.   do{
  217.     // Insert, insert 
  218.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  219.     CHECK(hugoOps.pkInsertRecord(pNdb, 1) == 0);
  220.     CHECK(hugoOps.execute_Commit(pNdb) == 0);
  221.     
  222.   } while(false);
  223.   
  224.   hugoOps.closeTransaction(pNdb);
  225.   
  226.   return result;
  227. }
  229. int
  230. runClearTable(NDBT_Context* ctx, NDBT_Step* step){
  231.   int records = ctx->getNumRecords();
  232.   
  233.   UtilTransactions utilTrans(*ctx->getTab());
  234.   if (utilTrans.clearTable2(GETNDB(step), records, 240) != 0){
  235.     return NDBT_FAILED;
  236.   }
  237.   return NDBT_OK;
  238. }
  240. enum OPS { o_DONE= 0, o_INS= 1, o_UPD= 2, o_DEL= 3 };
  241. typedef Vector<OPS> Sequence;
  243. static
  244. bool
  245. valid(const Sequence& s)
  246. { 
  247.   if(s.size() == 0)
  248.     return false;
  250.   for(size_t i = 1; i<s.size(); i++)
  251.   {
  252.     switch(s[i]){
  253.     case o_INS:
  254.       if(s[i-1] != o_DEL)
  255. return false;
  256.       break;
  257.     case o_UPD:
  258.     case o_DEL:
  259.       if(s[i-1] == o_DEL)
  260. return false;
  261.       break;
  262.     case o_DONE:
  263.       return true;
  264.     }
  265.   }
  266.   return true;
  267. }
  269. static
  270. NdbOut& operator<<(NdbOut& out, const Sequence& s)
  271. {
  272.   out << "[ ";
  273.   for(size_t i = 0; i<s.size(); i++)
  274.   {
  275.    switch(s[i]){
  276.     case o_INS:
  277.       out << "INS ";
  278.       break;
  279.     case o_DEL:
  280.       out << "DEL ";
  281.       break;
  282.     case o_UPD:
  283.       out << "UPD ";
  284.       break;
  285.    case o_DONE:
  286.      abort();
  287.    }
  288.   }
  289.   out << "]";
  290.   return out;
  291. }
  293. static
  294. void
  295. generate(Sequence& out, int no)
  296. {
  297.   while(no & 3)
  298.   {
  299.     out.push_back((OPS)(no & 3));
  300.     no >>= 2;
  301.   }
  302. }
  304. static
  305. void
  306. generate(Vector<int>& out, size_t len)
  307. {
  308.   int max= 1;
  309.   while(len)
  310.   {
  311.     max <<= 2;
  312.     len--;
  313.   }
  314.   
  315.   len= 1;
  316.   for(int i = 0; i<max; i++)
  317.   {
  318.     Sequence tmp;
  319.     generate(tmp, i);
  321.     if(tmp.size() >= len && valid(tmp))
  322.     {
  323.       out.push_back(i);
  324.       len= tmp.size();
  325.     }
  326.     else
  327.     {
  328.       //ndbout << "DISCARD: " << tmp << endl;
  329.     }
  330.   }
  331. }
  333. static const Uint32 DUMMY = 0;
  334. static const Uint32 ROW = 1;
  336. int
  337. verify_other(NDBT_Context* ctx,
  338.      Ndb* pNdb, int seq, OPS latest, bool initial_row, bool commit)
  339. {
  340.   Uint32 no_wait = NdbOperation::LM_CommittedRead*
  341.     ctx->getProperty("NoWait", (Uint32)1);
  343.   for(size_t j = no_wait; j<3; j++)
  344.   {
  345.     HugoOperations other(*ctx->getTab());
  346.     C3(other.startTransaction(pNdb) == 0);  
  347.     C3(other.pkReadRecord(pNdb, ROW, 1, (NdbOperation::LockMode)j) == 0);
  348.     int tmp= other.execute_Commit(pNdb);
  349.     if(seq == 0){
  350.       if(j == NdbOperation::LM_CommittedRead)
  351.       {
  352. C3(initial_row? tmp==0 && other.verifyUpdatesValue(0) == 0 : tmp==626);
  353.       }
  354.       else
  355.       {
  356. C3(tmp == 266);
  357.       }
  358.     }
  359.     else if(commit)
  360.     {
  361.       switch(latest){
  362.       case o_INS:
  363.       case o_UPD:
  364. C3(tmp == 0 && other.verifyUpdatesValue(seq) == 0);
  365. break;
  366.       case o_DEL:
  367. C3(tmp == 626);
  368. break;
  369.       case o_DONE:
  370. abort();
  371.       }
  372.     }
  373.     else 
  374.     {
  375.       // rollback
  376.       C3(initial_row? tmp==0 && other.verifyUpdatesValue(0) == 0 : tmp==626);
  377.     }
  378.   }
  379.   
  380.   return NDBT_OK;
  381. }
  383. int
  384. verify_savepoint(NDBT_Context* ctx,
  385.  Ndb* pNdb, int seq, OPS latest,
  386.  Uint64 transactionId)
  387. {
  388.   bool initial_row= (seq == 0) && latest == o_INS;
  390.   for(size_t j = 0; j<3; j++)
  391.   {
  392.     const NdbOperation::LockMode lm= (NdbOperation::LockMode)j;
  393.     
  394.     HugoOperations same(*ctx->getTab());
  395.     C3(same.startTransaction(pNdb) == 0);
  396.     same.setTransactionId(transactionId); // Cheat
  397.     
  398.     /**
  399.      * Increase savepoint to <em>k</em>
  400.      */
  401.     for(size_t l = 1; l<=seq; l++)
  402.     {
  403.       C3(same.pkReadRecord(pNdb, DUMMY, 1, lm) == 0); // Read dummy row
  404.       C3(same.execute_NoCommit(pNdb) == 0);
  405.       g_info << "savepoint: " << l << endl;
  406.     }   
  407.     
  408.     g_info << "op(" << seq << "): " 
  409.    << " lock mode " << lm << endl;
  410.     
  411.     C3(same.pkReadRecord(pNdb, ROW, 1, lm) == 0); // Read real row
  412.     int tmp= same.execute_Commit(pNdb);
  413.     if(seq == 0)
  414.     {
  415.       if(initial_row)
  416.       {
  417. C3(tmp == 0 && same.verifyUpdatesValue(0) == 0);
  418.       } else
  419.       {
  420. C3(tmp == 626);
  421.       }
  422.     }
  423.     else
  424.     {
  425.       switch(latest){
  426.       case o_INS:
  427.       case o_UPD:
  428. C3(tmp == 0 && same.verifyUpdatesValue(seq) == 0);
  429. break;
  430.       case o_DEL:
  431. C3(tmp == 626);
  432. break;
  433.       case o_DONE:
  434. abort();
  435.       }
  436.     }
  437.   }
  438.   return NDBT_OK;
  439. }
  441. int 
  442. runOperations(NDBT_Context* ctx, NDBT_Step* step)
  443. {
  444.   int tmp; 
  445.   Ndb* pNdb = GETNDB(step);
  446.   
  447.   Uint32 seqNo = ctx->getProperty("Sequence", (Uint32)0);
  448.   Uint32 commit= ctx->getProperty("Commit", (Uint32)1);
  449.   
  450.   if(seqNo == 0)
  451.   {
  452.     return NDBT_FAILED;
  453.   }
  455.   Sequence seq;
  456.   generate(seq, seqNo);
  458.   {
  459.     // Dummy row
  460.     HugoOperations hugoOps(*ctx->getTab());
  461.     C3(hugoOps.startTransaction(pNdb) == 0);  
  462.     C3(hugoOps.pkInsertRecord(pNdb, DUMMY, 1, 0) == 0);
  463.     C3(hugoOps.execute_Commit(pNdb) == 0);
  464.   }
  465.     
  466.   const bool initial_row= (seq[0] != o_INS);
  467.   if(initial_row)
  468.   {
  469.     HugoOperations hugoOps(*ctx->getTab());
  470.     C3(hugoOps.startTransaction(pNdb) == 0);  
  471.     C3(hugoOps.pkInsertRecord(pNdb, ROW, 1, 0) == 0);
  472.     C3(hugoOps.execute_Commit(pNdb) == 0);
  473.   }
  474.     
  475.   HugoOperations trans1(*ctx->getTab());
  476.   C3(trans1.startTransaction(pNdb) == 0);  
  477.   for(size_t i = 0; i<seq.size(); i++)
  478.   {
  479.     /**
  480.      * Perform operation
  481.      */
  482.     switch(seq[i]){
  483.     case o_INS:
  484.       C3(trans1.pkInsertRecord(pNdb, ROW, 1, i+1) == 0);
  485.       break;
  486.     case o_UPD:
  487.       C3(trans1.pkUpdateRecord(pNdb, ROW, 1, i+1) == 0);
  488.       break;
  489.     case o_DEL:
  490.       C3(trans1.pkDeleteRecord(pNdb, ROW, 1) == 0);
  491.       break;
  492.     case o_DONE:
  493.       abort();
  494.     }
  495.     C3(trans1.execute_NoCommit(pNdb) == 0);
  496.       
  497.     /**
  498.      * Verify other transaction
  499.      */
  500.     if(verify_other(ctx, pNdb, 0, seq[0], initial_row, commit) != NDBT_OK)
  501.       return NDBT_FAILED;
  502.     
  503.     /**
  504.      * Verify savepoint read
  505.      */
  506.     Uint64 transactionId= trans1.getTransaction()->getTransactionId();
  508.     for(size_t k=0; k<=i+1; k++)
  509.     {
  510.       if(verify_savepoint(ctx, pNdb, k, 
  511.   k>0 ? seq[k-1] : initial_row ? o_INS : o_DONE, 
  512.   transactionId) != NDBT_OK)
  513. return NDBT_FAILED;
  514.     }
  515.   }
  516.   
  517.   if(commit)
  518.   {
  519.     C3(trans1.execute_Commit(pNdb) == 0);
  520.   }
  521.   else
  522.   {
  523.     C3(trans1.execute_Rollback(pNdb) == 0);
  524.   }
  526.   if(verify_other(ctx, pNdb, seq.size(), seq.back(), 
  527.   initial_row, commit) != NDBT_OK)
  528.     return NDBT_FAILED;
  529.   
  530.   return NDBT_OK;
  531. }
  533. int
  534. runLockUpgrade1(NDBT_Context* ctx, NDBT_Step* step){
  535.   // Verify that data in index match 
  536.   // table data
  537.   Ndb* pNdb = GETNDB(step);
  538.   HugoOperations hugoOps(*ctx->getTab());
  539.   HugoTransactions hugoTrans(*ctx->getTab());
  541.   if(hugoTrans.loadTable(pNdb, 1) != 0){
  542.     g_err << "Load table failed" << endl;
  543.     return NDBT_FAILED;
  544.   }
  546.   int result= NDBT_OK;
  547.   do
  548.   {
  549.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  550.     if(ctx->getProperty("LOCK_UPGRADE", 1) == 1)
  551.     {
  552.       CHECK(hugoOps.pkReadRecord(pNdb, 0, 1, NdbOperation::LM_Read) == 0);
  553.       CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  554.     
  555.       ctx->setProperty("READ_DONE", 1);
  556.       ctx->broadcast();
  557.       ndbout_c("wait 2");
  558.       ctx->getPropertyWait("READ_DONE", 2);
  559.       ndbout_c("wait 2 - done");
  560.     }
  561.     else
  562.     {
  563.       ctx->setProperty("READ_DONE", 1);
  564.       ctx->broadcast();
  565.       ctx->getPropertyWait("READ_DONE", 2);
  566.       ndbout_c("wait 2 - done");
  567.       CHECK(hugoOps.pkReadRecord(pNdb, 0, 1, NdbOperation::LM_Read) == 0);
  568.       CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  569.     }
  570.     if(ctx->getProperty("LU_OP", o_INS) == o_INS)
  571.     {
  572.       CHECK(hugoOps.pkDeleteRecord(pNdb, 0, 1) == 0);
  573.       CHECK(hugoOps.pkInsertRecord(pNdb, 0, 1, 2) == 0);
  574.     }
  575.     else if(ctx->getProperty("LU_OP", o_UPD) == o_UPD)
  576.     {
  577.       CHECK(hugoOps.pkUpdateRecord(pNdb, 0, 1, 2) == 0);
  578.     } 
  579.     else
  580.     {
  581.       CHECK(hugoOps.pkDeleteRecord(pNdb, 0, 1) == 0);
  582.     }
  583.     ctx->setProperty("READ_DONE", 3);
  584.     ctx->broadcast();
  585.     ndbout_c("before update");
  586.     ndbout_c("wait update");
  587.     CHECK(hugoOps.execute_Commit(pNdb) == 0);
  588.     CHECK(hugoOps.closeTransaction(pNdb) == 0);
  590.     CHECK(hugoOps.startTransaction(pNdb) == 0);
  591.     CHECK(hugoOps.pkReadRecord(pNdb, 0, 1) == 0);
  592.     int res= hugoOps.execute_Commit(pNdb);
  593.     if(ctx->getProperty("LU_OP", o_INS) == o_INS)
  594.     {
  595.       CHECK(res == 0);
  596.       CHECK(hugoOps.verifyUpdatesValue(2) == 0);
  597.     }
  598.     else if(ctx->getProperty("LU_OP", o_UPD) == o_UPD)
  599.     {
  600.       CHECK(res == 0);
  601.       CHECK(hugoOps.verifyUpdatesValue(2) == 0);
  602.     } 
  603.     else
  604.     {
  605.       CHECK(res == 626);
  606.     }
  607.     
  608.   } while(0);
  609.   
  610.   return result;
  611. }
  613. int
  614. runLockUpgrade2(NDBT_Context* ctx, NDBT_Step* step){
  615.   // Verify that data in index match 
  616.   // table data
  617.   Ndb* pNdb = GETNDB(step);
  618.   HugoOperations hugoOps(*ctx->getTab());
  619.   HugoTransactions hugoTrans(*ctx->getTab());
  621.   
  622.   int result= NDBT_OK;
  623.   do
  624.   {
  625.     CHECK(hugoOps.startTransaction(pNdb) == 0);  
  626.     ndbout_c("wait 1");
  627.     ctx->getPropertyWait("READ_DONE", 1);
  628.     ndbout_c("wait 1 - done");
  629.     CHECK(hugoOps.pkReadRecord(pNdb, 0, 1, NdbOperation::LM_Read) == 0);
  630.     CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
  631.     ctx->setProperty("READ_DONE", 2);
  632.     ctx->broadcast();
  633.     ndbout_c("wait 3");
  634.     ctx->getPropertyWait("READ_DONE", 3);
  635.     ndbout_c("wait 3 - done");
  636.     
  637.     NdbSleep_MilliSleep(200);
  638.     if(ctx->getProperty("LU_COMMIT", (Uint32)0) == 0)
  639.     {
  640.       CHECK(hugoOps.execute_Commit(pNdb) == 0);
  641.     }
  642.     else
  643.     {
  644.       CHECK(hugoOps.execute_Rollback(pNdb) == 0);
  645.     }
  646.   } while(0);
  648.   return result;
  649. }
  651. int
  652. main(int argc, const char** argv){
  653.   ndb_init();
  655.   Vector<int> tmp;
  656.   generate(tmp, 5);
  658.   NDBT_TestSuite ts("testOperations");
  660.   for(Uint32 i = 0; i < 12; i++)
  661.   {
  662.     if(i == 6 || i == 8 || i == 10)
  663.       continue;
  665.     BaseString name("bug_9749");
  666.     name.appfmt("_%d", i);
  667.     NDBT_TestCaseImpl1 *pt = new NDBT_TestCaseImpl1(&ts, 
  668.     name.c_str(), "");    
  669.     
  670.     pt->setProperty("LOCK_UPGRADE", 1 + (i & 1));
  671.     pt->setProperty("LU_OP", 1 + ((i >> 1) % 3));
  672.     pt->setProperty("LU_COMMIT", i / 6);
  674.     pt->addInitializer(new NDBT_Initializer(pt,
  675.     "runClearTable", 
  676.     runClearTable));
  677.     
  678.     pt->addStep(new NDBT_ParallelStep(pt, 
  679.       "thread1",
  680.       runLockUpgrade1));
  681.     
  683.     pt->addStep(new NDBT_ParallelStep(pt, 
  684.       "thread2",
  685.       runLockUpgrade2));
  686.     
  687.     pt->addFinalizer(new NDBT_Finalizer(pt, 
  688. "runClearTable", 
  689. runClearTable));
  690.     ts.addTest(pt);
  691.   }
  693.   for(size_t i = 0; i<tmp.size(); i++)
  694.   {
  695.     BaseString name;
  696.     Sequence s;
  697.     generate(s, tmp[i]);
  698.     for(size_t j = 0; j<s.size(); j++){
  699.       switch(s[j]){
  700.       case o_INS:
  701. name.append("_INS");
  702. break;
  703.       case o_DEL:
  704. name.append("_DEL");
  705. break;
  706.       case o_UPD:
  707. name.append("_UPD");
  708. break;
  709.       case o_DONE:
  710. abort();
  711.       }
  712.     }
  714.     BaseString n1;
  715.     n1.append(name);
  716.     n1.append("_COMMIT");
  717.     
  718.     NDBT_TestCaseImpl1 *pt = new NDBT_TestCaseImpl1(&ts, 
  719.     n1.c_str()+1, "");    
  720.     
  721.     pt->setProperty("Sequence", tmp[i]);
  722.     pt->addInitializer(new NDBT_Initializer(pt, 
  723.     "runClearTable", 
  724.     runClearTable));
  726.     pt->addStep(new NDBT_ParallelStep(pt, 
  727.       "run",
  728.       runOperations));
  729.     
  730.     pt->addFinalizer(new NDBT_Finalizer(pt, 
  731. "runClearTable", 
  732. runClearTable));
  734.     ts.addTest(pt);
  736.     name.append("_ABORT");
  737.     pt = new NDBT_TestCaseImpl1(&ts, name.c_str()+1, "");    
  738.     pt->setProperty("Sequence", tmp[i]);
  739.     pt->setProperty("Commit", (Uint32)0);
  740.     pt->addInitializer(new NDBT_Initializer(pt, 
  741.     "runClearTable", 
  742.     runClearTable));
  743.     
  744.     pt->addStep(new NDBT_ParallelStep(pt, 
  745.       "run",
  746.       runOperations));
  747.     
  748.     pt->addFinalizer(new NDBT_Finalizer(pt, 
  749. "runClearTable", 
  750. runClearTable));
  751.     
  752.     ts.addTest(pt);
  753.   }
  754.   
  755.   for(Uint32 i = 0; i<sizeof(matrix)/sizeof(matrix[0]); i++){
  756.     NDBT_TestCaseImpl1 *pt = new NDBT_TestCaseImpl1(&ts, matrix[i].name, "");
  757.     
  758.     pt->addInitializer(new NDBT_Initializer(pt, 
  759.     "runClearTable", 
  760.     runClearTable));
  761.     
  762.     if(matrix[i].preCond){
  763.       pt->addInitializer(new NDBT_Initializer(pt, 
  764.       "runInsertRecord", 
  765.       runInsertRecord));
  766.     }
  767.     
  768.     pt->setProperty("op1", matrix[i].op1);
  769.     pt->setProperty("res1", matrix[i].res1);
  770.     pt->setProperty("val1", matrix[i].val1);
  772.     pt->setProperty("op2", matrix[i].op2);
  773.     pt->setProperty("res2", matrix[i].res2);
  774.     pt->setProperty("val2", matrix[i].val2);
  776.     pt->setProperty("res3", matrix[i].res3);
  777.     pt->setProperty("val3", matrix[i].val3);
  779.     pt->addStep(new NDBT_ParallelStep(pt, 
  780.       matrix[i].name,
  781.       runTwoOperations));
  782.     pt->addFinalizer(new NDBT_Finalizer(pt, 
  783. "runClearTable", 
  784. runClearTable));
  785.     
  786.     ts.addTest(pt);
  787.   }
  789.   return ts.execute(argc, argv);
  790. }
  792. template class Vector<OPS>;
  793. template class Vector<Sequence>;