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

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

MySQL数据库

开发平台：

Visual C++

testTransactions.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>
  22. #include <signaldata/DumpStateOrd.hpp>
  24. struct OperationTestCase {
  25.   const char * name;
  26.   bool preCond; // start transaction | insert | commit
  28.   // start transaction 1
  29.   const char * op1;
  30.   const int val1;
  32.   // no commit
  34.   // start transaction 2
  35.   const char * op2;
  36.   const int res2;
  37.   const int val2;
  38.   // no commit
  40.   // commit transaction 1
  41.   // commit transaction 2
  42.   
  43.   // start transaction
  44.   // op3 = READ
  45.   const int res3;
  46.   const int val3;
  47.   // commit transaction
  48. };
  50. #define X -1
  52. OperationTestCase matrix[] = {
  53.   { "ReadRead",         true, "READ",   1, "READ",      0, 1,   0, 1 },
  54.   { "ReadReadEx",       true, "READ",   1, "READ-EX", 266, X,   0, 1 },
  55.   { "ReadSimpleRead",   true, "READ",   1, "S-READ",    0, 1,   0, 1 },
  56.   { "ReadDirtyRead",    true, "READ",   1, "D-READ",    0, 1,   0, 1 },
  57.   { "ReadInsert",       true, "READ",   1, "INSERT",  266, X,   0, 1 },
  58.   { "ReadUpdate",       true, "READ",   1, "UPDATE",  266, X,   0, 1 },
  59.   { "ReadDelete",       true, "READ",   1, "DELETE",  266, X,   0, 1 },
  60.   { "ReadScan",         true, "READ",   1, "SCAN",      0, 1,   0, 1 },
  61.   { "ReadScanHl",       true, "READ",   1, "SCAN-HL",   0, 1,   0, 1 },
  62.   { "ReadScanEx",       true, "READ",   1, "SCAN-EX", 274, X,   0, 1 },
  63. #if 0
  64.   { "ReadScanUp",       true, "READ",   1, "SCAN-UP", 266, X,   0, 1 },
  65.   { "ReadScanDe",       true, "READ",   1, "SCAN-DE", 266, X,   0, 1 },
  66. #endif
  68.   { "ScanRead",         true, "SCAN",   1, "READ",      0, 1,   0, 1 },
  69.   { "ScanReadEx",       true, "SCAN",   1, "READ-EX",   0, 1,   0, 1 },
  70.   { "ScanSimpleRead",   true, "SCAN",   1, "S-READ",    0, 1,   0, 1 },
  71.   { "ScanDirtyRead",    true, "SCAN",   1, "D-READ",    0, 1,   0, 1 },
  72.   { "ScanInsert",       true, "SCAN",   1, "INSERT",  630, X,   0, 1 },
  73.   { "ScanUpdate",       true, "SCAN",   1, "UPDATE",    0, 2,   0, 2 },
  74.   { "ScanDelete",       true, "SCAN",   1, "DELETE",    0, X, 626, X },
  75.   { "ScanScan",         true, "SCAN",   1, "SCAN",      0, 1,   0, 1 },
  76.   { "ScanScanHl",       true, "SCAN",   1, "SCAN-HL",   0, 1,   0, 1 },
  77.   { "ScanScanEx",       true, "SCAN",   1, "SCAN-EX",   0, 1,   0, 1 },
  78. #if 0
  79.   { "ScanScanUp",       true, "SCAN",   1, "SCAN-UP", 266, X,   0, 1 },
  80.   { "ScanScanDe",       true, "SCAN",   1, "SCAN-DE", 266, X,   0, 1 },
  81. #endif
  83.   { "ScanHlRead",       true, "SCAN-HL",1, "READ",      0, 1,   0, 1 },
  84.   { "ScanHlReadEx",     true, "SCAN-HL",1, "READ-EX", 266, 1,   0, 1 },
  85.   { "ScanHlSimpleRead", true, "SCAN-HL",1, "S-READ",    0, 1,   0, 1 },
  86.   { "ScanHlDirtyRead",  true, "SCAN-HL",1, "D-READ",    0, 1,   0, 1 },
  87.   { "ScanHlInsert",     true, "SCAN-HL",1, "INSERT",  266, X,   0, 1 },
  88.   { "ScanHlUpdate",     true, "SCAN-HL",1, "UPDATE",  266, 2,   0, 1 },
  89.   { "ScanHlDelete",     true, "SCAN-HL",1, "DELETE",  266, X,   0, 1 },
  90.   { "ScanHlScan",       true, "SCAN-HL",1, "SCAN",      0, 1,   0, 1 },
  91.   { "ScanHlScanHl",     true, "SCAN-HL",1, "SCAN-HL",   0, 1,   0, 1 },
  92.   { "ScanHlScanEx",     true, "SCAN-HL",1, "SCAN-EX", 274, X,   0, 1 },
  93. #if 0
  94.   { "ScanHlScanUp",     true, "SCAN-HL",1, "SCAN-UP", 266, X,   0, 1 },
  95.   { "ScanHlScanDe",     true, "SCAN-HL",1, "SCAN-DE", 266, X,   0, 1 },
  96. #endif
  98.   { "ScanExRead",       true, "SCAN-EX",1, "READ",    266, 1,   0, 1 },
  99.   { "ScanExReadEx",     true, "SCAN-EX",1, "READ-EX", 266, 1,   0, 1 },
  100.   { "ScanExSimpleRead", true, "SCAN-EX",1, "S-READ",  266, 1,   0, 1 },
  101.   { "ScanExDirtyRead",  true, "SCAN-EX",1, "D-READ",    0, 1,   0, 1 },
  102.   { "ScanExInsert",     true, "SCAN-EX",1, "INSERT",  266, X,   0, 1 },
  103.   { "ScanExUpdate",     true, "SCAN-EX",1, "UPDATE",  266, 2,   0, 1 },
  104.   { "ScanExDelete",     true, "SCAN-EX",1, "DELETE",  266, X,   0, 1 },
  105.   { "ScanExScan",       true, "SCAN-EX",1, "SCAN",      0, 1,   0, 1 },
  106.   { "ScanExScanHl",     true, "SCAN-EX",1, "SCAN-HL", 274, X,   0, 1 },
  107.   { "ScanExScanEx",     true, "SCAN-EX",1, "SCAN-EX", 274, X,   0, 1 },
  108. #if 0
  109.   { "ScanExScanUp",     true, "SCAN-EX",1, "SCAN-UP", 266, X,   0, 1 },
  110.   { "ScanExScanDe",     true, "SCAN-EX",1, "SCAN-DE", 266, X,   0, 1 },
  111. #endif
  113.   { "ReadExRead",       true, "READ-EX",1, "READ",    266, X,   0, 1 },
  114.   { "ReadExReadEx",     true, "READ-EX",1, "READ-EX", 266, X,   0, 1 },
  115.   { "ReadExSimpleRead", true, "READ-EX",1, "S-READ",  266, X,   0, 1 },
  116.   { "ReadExDirtyRead",  true, "READ-EX",1, "D-READ",    0, 1,   0, 1 },
  117.   { "ReadExInsert",     true, "READ-EX",1, "INSERT",  266, X,   0, 1 },
  118.   { "ReadExUpdate",     true, "READ-EX",1, "UPDATE",  266, X,   0, 1 },
  119.   { "ReadExDelete",     true, "READ-EX",1, "DELETE",  266, X,   0, 1 },
  120.   { "ReadExScan",       true, "READ-EX",1, "SCAN",      0, 1,   0, 1 },
  121.   { "ReadExScanHl",     true, "READ-EX",1, "SCAN-HL", 274, X,   0, 1 },
  122.   { "ReadExScanEx",     true, "READ-EX",1, "SCAN-EX", 274, X,   0, 1 },
  123. #if 0
  124.   { "ReadExScanUp",     true, "READ-EX",1, "SCAN-UP", 266, X,   0, 1 },
  125.   { "ReadExScanDe",     true, "READ-EX",1, "SCAN-DE", 266, X,   0, 1 },
  126. #endif
  128.   { "InsertRead",      false, "INSERT", 1, "READ",    266, X,   0, 1 },
  129.   { "InsertReadEx",    false, "INSERT", 1, "READ-EX", 266, X,   0, 1 },
  130.   { "InsertSimpleRead",false, "INSERT", 1, "S-READ",  266, X,   0, 1 },
  131.   { "InsertDirtyRead", false, "INSERT", 1, "D-READ",  626, X,   0, 1 },
  132.   { "InsertInsert",    false, "INSERT", 1, "INSERT",  266, X,   0, 1 },
  133.   { "InsertUpdate",    false, "INSERT", 1, "UPDATE",  266, X,   0, 1 },
  134.   { "InsertDelete",    false, "INSERT", 1, "DELETE",  266, X,   0, 1 },
  135.   { "InsertScan",      false, "INSERT", 1, "SCAN",    626, X,   0, 1 },
  136.   { "InsertScanHl",    false, "INSERT", 1, "SCAN-HL", 274, X,   0, 1 },
  137.   { "InsertScanEx",    false, "INSERT", 1, "SCAN-EX", 274, X,   0, 1 },
  138. #if 0
  139.   { "InsertScanUp",    false, "INSERT",   1, "SCAN-UP", 266, X,   0, 1 },
  140.   { "InsertScanDe",    false, "INSERT",   1, "SCAN-DE", 266, X,   0, 1 },
  141. #endif
  143.   { "UpdateRead",       true, "UPDATE", 2, "READ",    266, X,   0, 2 },
  144.   { "UpdateReadEx",     true, "UPDATE", 2, "READ-EX", 266, X,   0, 2 },
  145.   { "UpdateSimpleRead", true, "UPDATE", 2, "S-READ",  266, X,   0, 2 },
  146.   { "UpdateDirtyRead",  true, "UPDATE", 2, "D-READ",    0, 1,   0, 2 },
  147.   { "UpdateInsert",     true, "UPDATE", 2, "INSERT",  266, X,   0, 2 },
  148.   { "UpdateUpdate",     true, "UPDATE", 2, "UPDATE",  266, X,   0, 2 },
  149.   { "UpdateDelete",     true, "UPDATE", 2, "DELETE",  266, X,   0, 2 },
  150.   { "UpdateScan",       true, "UPDATE", 2, "SCAN",      0, 1,   0, 2 },
  151.   { "UpdateScanHl",     true, "UPDATE", 2, "SCAN-HL", 274, X,   0, 2 },
  152.   { "UpdateScanEx",     true, "UPDATE", 2, "SCAN-EX", 274, X,   0, 2 },
  153. #if 0
  154.   { "UpdateScanUp",     true, "UPDATE", 2, "SCAN-UP", 266, X,   0, 2 },
  155.   { "UpdateScanDe",     true, "UPDATE", 2, "SCAN-DE", 266, X,   0, 2 },
  156. #endif
  158.   { "DeleteRead",       true, "DELETE", X, "READ",    266, X, 626, X },
  159.   { "DeleteReadEx",     true, "DELETE", X, "READ-EX", 266, X, 626, X },
  160.   { "DeleteSimpleRead", true, "DELETE", X, "S-READ",  266, X, 626, X },
  161.   { "DeleteDirtyRead",  true, "DELETE", X, "D-READ",    0, 1, 626, X },
  162.   { "DeleteInsert",     true, "DELETE", X, "INSERT",  266, X, 626, X },
  163.   { "DeleteUpdate",     true, "DELETE", X, "UPDATE",  266, X, 626, X },
  164.   { "DeleteDelete",     true, "DELETE", X, "DELETE",  266, X, 626, X },
  165.   { "DeleteScan",       true, "DELETE", X, "SCAN",      0, 1, 626, X },
  166.   { "DeleteScanHl",     true, "DELETE", X, "SCAN-HL", 274, X, 626, X },
  167.   { "DeleteScanEx",     true, "DELETE", X, "SCAN-EX", 274, X, 626, X },
  168. #if 0
  169.   { "DeleteScanUp",     true, "DELETE", X, "SCAN-UP", 266, X, 626, X },
  170.   { "DeleteScanDe",     true, "DELETE", X, "SCAN-DE", 266, X, 626, X }
  171. #endif
  173. };
  175. #define CHECK(a, b) { int x = a; int y = b; if (x != y) { 
  176.   g_err  << "ERR: "<< step->getName() 
  177.          << " failed on line " << __LINE__ << endl << "  " 
  178.          << x << " != " << y << endl;
  179.    result = NDBT_FAILED; 
  180.   break; } }
  182. int
  183. runOp(HugoOperations & hugoOps,
  184.       Ndb * pNdb,
  185.       const char * op,
  186.       int value){
  188. #define C2(x) if(!(x)) {
  189.   g_err  << "ERR: failed on line " << __LINE__ << endl; 
  190.   return NDBT_FAILED; }
  191.   
  192.   if(strcmp(op, "READ") == 0){
  193.     C2(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Read) == 0);
  194.   } else if(strcmp(op, "READ-EX") == 0){
  195.     C2(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0);  
  196.   } else if(strcmp(op, "S-READ") == 0){
  197.     C2(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Read) == 0);      
  198.   } else if(strcmp(op, "D-READ") == 0){
  199.     C2(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_CommittedRead) == 0); 
  200.   } else if(strcmp(op, "INSERT") == 0){
  201.     C2(hugoOps.pkInsertRecord(pNdb, 1, 1, value) == 0);      
  202.   } else if(strcmp(op, "UPDATE") == 0){
  203.     C2(hugoOps.pkUpdateRecord(pNdb, 1, 1, value) == 0);      
  204.   } else if(strcmp(op, "DELETE") == 0){
  205.     C2(hugoOps.pkDeleteRecord(pNdb, 1, 1) == 0);      
  206.   } else if(strcmp(op, "SCAN") == 0){
  207.     C2(hugoOps.scanReadRecords(pNdb) == 0);
  208.   } else if(strcmp(op, "SCAN-HL") == 0){
  209.     C2(hugoOps.scanReadRecords(pNdb, NdbScanOperation::LM_Read)== 0);
  210.   } else if(strcmp(op, "SCAN-EX") == 0){
  211.     C2(hugoOps.scanReadRecords(pNdb, NdbScanOperation::LM_Exclusive)== 0);
  212.   } else {
  213.     g_err << __FILE__ << " - " << __LINE__ 
  214.   << ": Unknown operation" << op << endl;
  215.     return NDBT_FAILED;
  216.   }
  217.   
  218.   return NDBT_OK;
  219. }
  221. int
  222. checkVal(HugoOperations & hugoOps,
  223.  const char * op,
  224.  int value,
  225.  int result){
  227.   if(result != 0)
  228.     return NDBT_OK;
  230.   if(strcmp(op, "READ") == 0){
  231.   } else if(strcmp(op, "READ-EX") == 0){
  232.   } else if(strcmp(op, "S-READ") == 0){
  233.   } else if(strcmp(op, "D-READ") == 0){
  234.   } else if(strcmp(op, "SCAN") == 0){
  235.   } else if(strcmp(op, "SCAN-HL") == 0){
  236.   } else if(strcmp(op, "SCAN-EX") == 0){
  237.   } else {
  238.     return NDBT_OK;
  239.   }
  240.   
  241.   return hugoOps.verifyUpdatesValue(value);
  242. }
  244. #define TIMEOUT 100
  246. int
  247. setTransactionTimeout(NDBT_Context* ctx, NDBT_Step* step){
  248.   NdbRestarter restarter;
  250.   int val[] = 
  251.     { DumpStateOrd::TcSetTransactionTimeout, TIMEOUT };
  252.   if(restarter.dumpStateAllNodes(val, 2) != 0){
  253.     return NDBT_FAILED;
  254.   }
  256.   return NDBT_OK;
  257. }
  259. int 
  260. runTwoTrans1(NDBT_Context* ctx, NDBT_Step* step){
  261.   int result = NDBT_OK;
  262.   HugoOperations T1(*ctx->getTab());
  263.   Ndb* pNdb = GETNDB(step);
  264.   
  265.   const char * op1 = ctx->getProperty("op1", "NONE");
  266.   int val1 = ctx->getProperty("val1", ~0);
  268.   do {
  269.     // Insert, read
  270.     CHECK(T1.startTransaction(pNdb), 0);  
  271.     CHECK(runOp(T1, pNdb, op1, val1), 0);
  272.     CHECK(T1.execute_NoCommit(pNdb),  0);
  273.     CHECK(checkVal(T1, op1, val1, 0), 0);
  274.     
  275.     ctx->setProperty("T1-1-Complete", 1);
  276.     while(ctx->getProperty("T2-Complete", (Uint32)0) == 0){
  277.       T1.refresh();
  278.       NdbSleep_MilliSleep(10);
  279.     }
  280.     
  281.     CHECK(T1.execute_Commit(pNdb), 0);
  282.     
  283.   } while(false);
  284.   T1.closeTransaction(pNdb);
  285.   
  286.   if(result != NDBT_OK)
  287.     return result;
  289.   const int res3 = ctx->getProperty("res3", ~0);
  290.   const int val3 = ctx->getProperty("val3", ~0);
  291.   
  292.   do {
  293.     CHECK(T1.startTransaction(pNdb), 0);
  294.     CHECK(runOp(T1, pNdb, "READ", 0), 0);
  295.     CHECK(T1.execute_Commit(pNdb), res3);
  296.     CHECK(checkVal(T1, "READ", val3, res3), 0);
  297.   } while(false);
  298.   T1.closeTransaction(pNdb);
  299.   
  300.   return result;
  301. }
  303. int 
  304. runTwoTrans2(NDBT_Context* ctx, NDBT_Step* step){
  305.   int result = NDBT_OK;
  306.   HugoOperations T2(*ctx->getTab());
  307.   Ndb* pNdb = GETNDB(step);
  308.   
  309.   const char * op2 = ctx->getProperty("op2", "NONE");
  310.   const int res2 = ctx->getProperty("res2", ~0);
  311.   const int val2 = ctx->getProperty("val2", ~0);
  313.   while(ctx->getProperty("T1-1-Complete", (Uint32)0) == 0 && 
  314. !ctx->isTestStopped()){
  315.     NdbSleep_MilliSleep(100);
  316.   }
  318.   if(!ctx->isTestStopped()){
  319.     do {
  320.       CHECK(T2.startTransaction(pNdb), 0);  
  321.       CHECK(runOp(T2, pNdb, op2, val2), 0);
  322.       CHECK(T2.execute_NoCommit(pNdb), res2);
  323.       CHECK(checkVal(T2, op2, val2, res2), 0);
  324.       if(res2 == 0){
  325. CHECK(T2.execute_Commit(pNdb), res2);
  326.       }
  327.     } while(false);
  328.     T2.closeTransaction(pNdb);
  329.   }
  330.   
  331.   ctx->setProperty("T2-Complete", 1);  
  332.   
  333.   return result;
  334. }
  336. int 
  337. runInsertRecord(NDBT_Context* ctx, NDBT_Step* step){
  338.   int result = NDBT_OK;
  339.   HugoOperations hugoOps(*ctx->getTab());
  340.   Ndb* pNdb = GETNDB(step);
  341.   
  342.   do{
  343.     // Insert, insert 
  344.     CHECK(hugoOps.startTransaction(pNdb), 0);  
  345.     CHECK(hugoOps.pkInsertRecord(pNdb, 1, 1, 1), 0);
  346.     CHECK(hugoOps.execute_Commit(pNdb), 0);    
  347.   } while(false);
  348.   
  349.   hugoOps.closeTransaction(pNdb);
  350.   
  351.   return result;
  352. }
  354. int
  355. runClearTable(NDBT_Context* ctx, NDBT_Step* step){
  356.   int records = ctx->getNumRecords();
  357.   
  358.   UtilTransactions utilTrans(*ctx->getTab());
  359.   if (utilTrans.clearTable2(GETNDB(step), records, 240) != 0){
  360.     return NDBT_FAILED;
  361.   }
  362.   return NDBT_OK;
  363. }
  365. int
  366. main(int argc, const char** argv){
  367.   ndb_init();
  369.   NDBT_TestSuite ts("testOperations");
  370.   for(Uint32 i = 0; i<sizeof(matrix)/sizeof(matrix[0]); i++){
  371.     NDBT_TestCaseImpl1 *pt = new NDBT_TestCaseImpl1(&ts, matrix[i].name, "");
  372.     
  373.     pt->addInitializer(new NDBT_Initializer(pt, 
  374.     "runClearTable", 
  375.     runClearTable));
  376.     
  377.     if(matrix[i].preCond){
  378.       pt->addInitializer(new NDBT_Initializer(pt, 
  379.       "runInsertRecord", 
  380.       runInsertRecord));
  381.     }
  382.     
  383.     pt->addInitializer(new NDBT_Initializer(pt, 
  384.     "setTransactionTimeout", 
  385.     setTransactionTimeout));
  386.     
  387.     pt->setProperty("op1", matrix[i].op1);
  388.     pt->setProperty("val1", matrix[i].val1);
  390.     pt->setProperty("op2", matrix[i].op2);
  391.     pt->setProperty("res2", matrix[i].res2);
  392.     pt->setProperty("val2", matrix[i].val2);
  394.     pt->setProperty("res3", matrix[i].res3);
  395.     pt->setProperty("val3", matrix[i].val3);
  397.     pt->addStep(new NDBT_ParallelStep(pt, 
  398.       matrix[i].name,
  399.       runTwoTrans1));
  400.     pt->addStep(new NDBT_ParallelStep(pt, 
  401.       matrix[i].name,
  402.       runTwoTrans2));
  403.     pt->addFinalizer(new NDBT_Finalizer(pt, 
  404. "runClearTable", 
  405. runClearTable));
  406.     
  407.     ts.addTest(pt);
  408.   }
  410.   return ts.execute(argc, argv);
  411. }