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

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

MySQL数据库

开发平台：

Visual C++

acid.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 <NdbApi.hpp>
  18. #include <NdbSchemaCon.hpp>
  19. #include <NdbMutex.h>
  20. #include <NdbOut.hpp>
  21. #include <NdbSleep.h>
  22. #include <NdbThread.h>
  23. #include <NdbTick.h>
  24. #include <NdbMain.h>
  25. #include <NdbTest.hpp>
  26. #include <random.h>
  28. //#define TRACE
  29. #define DEBUG
  30. //#define RELEASE
  31. #define NODE_REC // epaulsa: introduces pointer checks to help 'acid' keep core
  32. // during node recovery
  34. #ifdef TRACE
  36. #define VerifyMethodInt(c, m) (ReportMethodInt(c->m, c, #c, #m, __FILE__, __LINE__))
  37. #define VerifyMethodPtr(v, c, m) (v=ReportMethodPtr(c->m, c, #v, #c, #m, __FILE__, __LINE__))
  38. #define VerifyMethodVoid(c, m) (c->m, ReportMethodVoid(c, #c, #m, __FILE__, __LINE__))
  40. int ReportMethodInt(int iRes, NdbConnection* pNdbConnection, const char* szClass, const char* szMethod, const char* szFile, const int iLine)
  41. {
  42.   ndbout << szFile << "(" << iLine << ") : ";
  43.   ndbout << szClass << "->" << szMethod << " return " << iRes << " : ";
  44.   ndbout << pNdbConnection->getNdbError();
  45.   NdbOperation* pNdbOperation = pNdbConnection->getNdbErrorOperation();
  46.   if(pNdbOperation) {
  47.     ndbout << " : " << pNdbOperation->getNdbError();
  48.   }
  49.   ndbout << " : " << pNdbConnection->getNdbErrorLine();
  50.   ndbout << endl;
  51.   return iRes;
  52. }
  54. template <class C>
  55. int ReportMethodInt(int iRes, C* pC, const char* szClass, const char* szMethod, const char* szFile, const int iLine)
  56. {
  57.   ndbout << szFile << "(" << iLine << ") : ";
  58.   ndbout << szClass << "->" << szMethod << " return " << iRes << " : ";
  59.   ndbout << pC->getNdbError();
  60.   ndbout << endl;
  61.   return iRes;
  62. }
  64. template <class R, class C>
  65. R* ReportMethodPtr(R* pR, C* pC, const char* szVariable, const char* szClass, const char* szMethod, const char* szFile, const int iLine)
  66. {
  67.   ndbout << szFile << "(" << iLine << ") : ";
  68.   ndbout << szVariable << " = " << szClass << "->" << szMethod << " return " << (long)(void*)pR << " : ";
  69.   ndbout << pC->getNdbError();
  70.   ndbout << endl;
  71.   return pR;
  72. }
  74. template <class C>
  75. void ReportMethodVoid(C* pC, const char* szClass, const char* szMethod, const char* szFile, const int iLine)
  76. {
  77.   ndbout << szFile << "(" << iLine << ") : ";
  78.   ndbout << szClass << "->" << szMethod << " : ";
  79.   ndbout << pC->getNdbError();
  80.   ndbout << endl;
  81. }
  82. #endif /* TRACE */
  85. #ifdef DEBUG
  87. #define VerifyMethodInt(c, m) (ReportMethodInt(c->m, c, #c, #m, __FILE__, __LINE__))
  88. #define VerifyMethodPtr(v, c, m) (v=ReportMethodPtr(c->m, c, #v, #c, #m, __FILE__, __LINE__))
  89. #define VerifyMethodVoid(c, m) (c->m, ReportMethodVoid(c, #c, #m, __FILE__, __LINE__))
  91. int ReportMethodInt(int iRes, NdbConnection* pNdbConnection, const char* szClass, const char* szMethod, const char* szFile, const int iLine)
  92. {
  93.   if(iRes<0) {
  94.     ndbout << szFile << "(" << iLine << ") : ";
  95.     ndbout << szClass << "->" << szMethod << " return " << iRes << " : ";
  96.     ndbout << pNdbConnection->getNdbError();
  97.     NdbOperation* pNdbOperation = pNdbConnection->getNdbErrorOperation();
  98.     if(pNdbOperation) {
  99.       ndbout << " : " << pNdbOperation->getNdbError();
  100.     }
  101.     ndbout << " : " << pNdbConnection->getNdbErrorLine();
  102.     ndbout << " : ";
  103.     ndbout << endl;
  104.   }
  105.   return iRes;
  106. }
  108. template <class C>
  109. int ReportMethodInt(int iRes, C* pC, const char* szClass, const char* szMethod, const char* szFile, const int iLine)
  110. {
  111.   if(iRes<0) {
  112.     ndbout << szFile << "(" << iLine << ") : ";
  113.     ndbout << szClass << "->" << szMethod << " return " << iRes << " : ";
  114.     ndbout << pC->getNdbError();
  115.     ndbout << endl;
  116.   }
  117.   return iRes;
  118. }
  120. template <class R, class C>
  121. R* ReportMethodPtr(R* pR, C* pC, const char* szVariable, const char* szClass, const char* szMethod, const char* szFile, const int iLine)
  122. {
  123.   if(!pR) {
  124.     ndbout << szFile << "(" << iLine << ") : ";
  125.     ndbout << szVariable << " = " << szClass << "->" << szMethod << " return " << " : ";
  126.     ndbout << pC->getNdbError();
  127.     ndbout << endl;
  128.   }
  129.   return pR;
  130. }
  132. template <class C>
  133. void ReportMethodVoid(C* pC, const char* szClass, const char* szMethod, const char* szFile, const int iLine)
  134. {
  135.   if(pC->getNdbError().code) {
  136.     ndbout << szFile << "(" << iLine << ") : ";
  137.     ndbout << szClass << "->" << szMethod << " : ";
  138.     ndbout << pC->getNdbError();
  139.     ndbout << endl;
  140.   }
  141. }
  144. #endif /* DEBUG */
  147. #ifdef RELEASE
  149. #define VerifyMethodInt(c, m) (c->m)
  150. #define VerifyMethodPtr(v, c, m) (v=(c->m))
  151. #define VerifyMethodVoid(c, m) (c->m)
  153. int ReportMethodInt(int iRes, NdbConnection* pNdbConnection, const char* szClass, const char* szMethod, const char* szFile, const int iLine)
  154. {
  155.   if(iRes<0) {
  156.     ndbout << szFile << "(" << iLine << ") : ";
  157.     ndbout << szClass << "->" << szMethod << " return " << iRes << " : ";
  158.     ndbout << pNdbConnection->getNdbError();
  159.     NdbOperation* pNdbOperation = pNdbConnection->getNdbErrorOperation();
  160.     if(pNdbOperation) {
  161.       ndbout << " : " << pNdbOperation->getNdbError();
  162.     }
  163.     ndbout << " : " << pNdbConnection->getNdbErrorLine();
  164.     ndbout << endl;
  165.   }
  166.   return iRes;
  167. }
  169. #endif /* RELEASE */
  171. // epaulsa =>
  172. #ifndef NODE_REC
  173. #define CHK_TR(p)
  174. #else
  175. #define CHK_TR(p) if(!p){
  176. ndbout <<"startTransaction failed, returning now." << endl ;
  177. delete pNdb ;
  178. pNdb = NULL ;
  179. return 0 ;
  180. }
  181. #endif // NODE_REC
  182. // <= epaulsa
  184. const char* c_szWarehouse = "WAREHOUSE";
  185. const char* c_szWarehouseNumber = "W_ID";
  186. const char* c_szWarehouseSum = "W_SUM";
  187. const char* c_szWarehouseCount = "W_CNT";
  188. const char* c_szDistrict = "DISTRICT";
  189. const char* c_szDistrictWarehouseNumber = "D_W_ID";
  190. const char* c_szDistrictNumber = "D_ID";
  191. const char* c_szDistrictSum = "D_SUM";
  192. const char* c_szDistrictCount = "D_CNT";
  194. Uint32 g_nWarehouseCount = 10;
  195. Uint32 g_nDistrictPerWarehouse = 10;
  196. Uint32 g_nThreadCount = 1;
  197. NdbMutex* g_pNdbMutex = 0;
  199. extern "C" void* NdbThreadFuncInsert(void* pArg)
  200. {
  201.   myRandom48Init((long int)NdbTick_CurrentMillisecond());
  202.   unsigned nSucc = 0;
  203.   unsigned nFail = 0;
  204.   Ndb* pNdb = NULL ;
  205.   pNdb = new Ndb("TEST_DB");
  206.   VerifyMethodInt(pNdb, init());
  207.   VerifyMethodInt(pNdb, waitUntilReady());
  209.   while(NdbMutex_Trylock(g_pNdbMutex)) {
  210.     Uint32 nWarehouse = myRandom48(g_nWarehouseCount);
  211.     NdbConnection* pNdbConnection = NULL ;
  212.     VerifyMethodPtr(pNdbConnection, pNdb, startTransaction());
  213.     CHK_TR(pNdbConnection);
  214.     NdbOperation* pNdbOperationW = NULL ;
  215.     VerifyMethodPtr(pNdbOperationW, pNdbConnection, getNdbOperation(c_szWarehouse));
  216.     VerifyMethodInt(pNdbOperationW, insertTuple());
  217.     VerifyMethodInt(pNdbOperationW, equal(c_szWarehouseNumber, nWarehouse));
  218.     VerifyMethodInt(pNdbOperationW, setValue(c_szWarehouseCount, Uint32(1)));
  219.     Uint32 nWarehouseSum = 0;
  220.     for(Uint32 nDistrict=0; nDistrict<g_nDistrictPerWarehouse; ++nDistrict) {
  221.       NdbOperation* pNdbOperationD = NULL ;
  222.       VerifyMethodPtr(pNdbOperationD, pNdbConnection, getNdbOperation(c_szDistrict));
  223.       VerifyMethodInt(pNdbOperationD, insertTuple());
  224.       VerifyMethodInt(pNdbOperationD, equal(c_szDistrictWarehouseNumber, nWarehouse));
  225.       VerifyMethodInt(pNdbOperationD, equal(c_szDistrictNumber, nDistrict));
  226.       VerifyMethodInt(pNdbOperationD, setValue(c_szDistrictCount, Uint32(1)));
  227.       Uint32 nDistrictSum = myRandom48(100);
  228.       nWarehouseSum += nDistrictSum;
  229.       VerifyMethodInt(pNdbOperationD, setValue(c_szDistrictSum, nDistrictSum));
  230.     }
  231.     VerifyMethodInt(pNdbOperationW, setValue(c_szWarehouseSum, nWarehouseSum));
  232.     int iExec = pNdbConnection->execute(Commit);
  233.     int iError = pNdbConnection->getNdbError().code;
  235.     if(iExec<0 && iError!=0 && iError!=266 && iError!=630) {
  236.       ReportMethodInt(iExec, pNdbConnection, "pNdbConnection", "execute(Commit)", __FILE__, __LINE__);
  237.     }
  238.     if(iExec==0) {
  239.       ++nSucc;
  240.     } else {
  241.       ++nFail;
  242.     }
  243.     VerifyMethodVoid(pNdb, closeTransaction(pNdbConnection));
  244.   }
  245.   ndbout << "insert: " << nSucc << " succeeded, " << nFail << " failed " << endl;
  246.   NdbMutex_Unlock(g_pNdbMutex);
  247.   delete pNdb;
  248.   pNdb = NULL ;
  249.   return NULL;
  250. }
  253. extern "C" void* NdbThreadFuncUpdate(void* pArg)
  254. {
  255.   myRandom48Init((long int)NdbTick_CurrentMillisecond());
  256.   unsigned nSucc = 0;
  257.   unsigned nFail = 0;
  258.   Ndb* pNdb = NULL ;
  259.   pNdb = new Ndb("TEST_DB");
  260.   VerifyMethodInt(pNdb, init());
  261.   VerifyMethodInt(pNdb, waitUntilReady());
  263.   while(NdbMutex_Trylock(g_pNdbMutex)) {
  264.     Uint32 nWarehouse = myRandom48(g_nWarehouseCount);
  265.     NdbConnection* pNdbConnection = NULL ;
  266.     VerifyMethodPtr(pNdbConnection, pNdb, startTransaction());
  267.     CHK_TR(pNdbConnection) ; // epaulsa
  268.     NdbOperation* pNdbOperationW = NULL ;
  269.     VerifyMethodPtr(pNdbOperationW, pNdbConnection, getNdbOperation(c_szWarehouse));
  270.     VerifyMethodInt(pNdbOperationW, interpretedUpdateTuple());
  271.     VerifyMethodInt(pNdbOperationW, equal(c_szWarehouseNumber, nWarehouse));
  272.     VerifyMethodInt(pNdbOperationW, incValue(c_szWarehouseCount, Uint32(1)));
  273.     Uint32 nWarehouseSum = 0;
  274.     for(Uint32 nDistrict=0; nDistrict<g_nDistrictPerWarehouse; ++nDistrict) {
  275.       NdbOperation* pNdbOperationD = NULL ;
  276.       VerifyMethodPtr(pNdbOperationD, pNdbConnection, getNdbOperation(c_szDistrict));
  277.       VerifyMethodInt(pNdbOperationD, interpretedUpdateTuple());
  278.       VerifyMethodInt(pNdbOperationD, equal(c_szDistrictWarehouseNumber, nWarehouse));
  279.       VerifyMethodInt(pNdbOperationD, equal(c_szDistrictNumber, nDistrict));
  280.       VerifyMethodInt(pNdbOperationD, incValue(c_szDistrictCount, Uint32(1)));
  281.       Uint32 nDistrictSum = myRandom48(100);
  282.       nWarehouseSum += nDistrictSum;
  283.       VerifyMethodInt(pNdbOperationD, setValue(c_szDistrictSum, nDistrictSum));
  284.     }
  285.     VerifyMethodInt(pNdbOperationW, setValue(c_szWarehouseSum, nWarehouseSum));
  286.     int iExec = pNdbConnection->execute(Commit);
  287.     int iError = pNdbConnection->getNdbError().code;
  289.     if(iExec<0 && iError!=0 && iError!=266 && iError!=626) {
  290.       ReportMethodInt(iExec, pNdbConnection, "pNdbConnection", "execute(Commit)", __FILE__, __LINE__);
  291.     }
  292.     if(iExec==0) {
  293.       ++nSucc;
  294.     } else {
  295.       ++nFail;
  296.     }
  297.     VerifyMethodVoid(pNdb, closeTransaction(pNdbConnection));
  298.   }
  299.   ndbout << "update: " << nSucc << " succeeded, " << nFail << " failed " << endl;
  300.   NdbMutex_Unlock(g_pNdbMutex);
  301.   delete pNdb;
  302.   pNdb = NULL ;
  303.   return NULL;
  304. }
  307. extern "C" void* NdbThreadFuncDelete(void* pArg)
  308. {
  309.   myRandom48Init((long int)NdbTick_CurrentMillisecond());
  310.   unsigned nSucc = 0;
  311.   unsigned nFail = 0;
  312.   Ndb* pNdb = NULL ;
  313.   pNdb = new Ndb("TEST_DB");
  314.   VerifyMethodInt(pNdb, init());
  315.   VerifyMethodInt(pNdb, waitUntilReady());
  317.   while(NdbMutex_Trylock(g_pNdbMutex)) {
  318.     Uint32 nWarehouse = myRandom48(g_nWarehouseCount);
  319.     NdbConnection* pNdbConnection = NULL ;
  320.     VerifyMethodPtr(pNdbConnection, pNdb, startTransaction());
  321.     CHK_TR(pNdbConnection) ; // epaulsa
  322.     NdbOperation* pNdbOperationW = NULL ;
  323.     VerifyMethodPtr(pNdbOperationW, pNdbConnection, getNdbOperation(c_szWarehouse));
  324.     VerifyMethodInt(pNdbOperationW, deleteTuple());
  325.     VerifyMethodInt(pNdbOperationW, equal(c_szWarehouseNumber, nWarehouse));
  326.     for(Uint32 nDistrict=0; nDistrict<g_nDistrictPerWarehouse; ++nDistrict) {
  327.       NdbOperation* pNdbOperationD = NULL ;
  328.       VerifyMethodPtr(pNdbOperationD, pNdbConnection, getNdbOperation(c_szDistrict));
  329.       VerifyMethodInt(pNdbOperationD, deleteTuple());
  330.       VerifyMethodInt(pNdbOperationD, equal(c_szDistrictWarehouseNumber, nWarehouse));
  331.       VerifyMethodInt(pNdbOperationD, equal(c_szDistrictNumber, nDistrict));
  332.     }
  333.     int iExec = pNdbConnection->execute(Commit);
  334.     int iError = pNdbConnection->getNdbError().code;
  336.     if(iExec<0 && iError!=0 && iError!=266 && iError!=626) {
  337.       ReportMethodInt(iExec, pNdbConnection, "pNdbConnection", "execute(Commit)", __FILE__, __LINE__);
  338.     }
  339.     if(iExec==0) {
  340.       ++nSucc;
  341.     } else {
  342.       ++nFail;
  343.     }
  344.     VerifyMethodVoid(pNdb, closeTransaction(pNdbConnection));
  345.   }
  346.   ndbout << "delete: " << nSucc << " succeeded, " << nFail << " failed " << endl;
  347.   NdbMutex_Unlock(g_pNdbMutex);
  348.   delete pNdb;
  349.   pNdb = NULL ;
  350.   return NULL;
  351. }
  354. extern "C" void* NdbThreadFuncRead(void* pArg)
  355. {
  356.   myRandom48Init((long int)NdbTick_CurrentMillisecond());
  357.   unsigned nSucc = 0;
  358.   unsigned nFail = 0;
  359.   NdbRecAttr** ppNdbRecAttrDSum = new NdbRecAttr*[g_nDistrictPerWarehouse];
  360.   NdbRecAttr** ppNdbRecAttrDCnt = new NdbRecAttr*[g_nDistrictPerWarehouse];
  361.   Ndb* pNdb = NULL ;
  362.   pNdb = new Ndb("TEST_DB");
  363.   VerifyMethodInt(pNdb, init());
  364.   VerifyMethodInt(pNdb, waitUntilReady());
  366.   while(NdbMutex_Trylock(g_pNdbMutex)) {
  367.     Uint32 nWarehouse = myRandom48(g_nWarehouseCount);
  368.     NdbConnection* pNdbConnection = NULL ;
  369.     VerifyMethodPtr(pNdbConnection, pNdb, startTransaction());
  370.     CHK_TR(pNdbConnection) ; // epaulsa
  371.     NdbOperation* pNdbOperationW = NULL ;
  372.     VerifyMethodPtr(pNdbOperationW, pNdbConnection, getNdbOperation(c_szWarehouse));
  373.     VerifyMethodInt(pNdbOperationW, readTuple());
  374.     VerifyMethodInt(pNdbOperationW, equal(c_szWarehouseNumber, nWarehouse));
  375.     NdbRecAttr* pNdbRecAttrWSum;
  376.     VerifyMethodPtr(pNdbRecAttrWSum, pNdbOperationW, getValue(c_szWarehouseSum, 0));
  377.     NdbRecAttr* pNdbRecAttrWCnt;
  378.     VerifyMethodPtr(pNdbRecAttrWCnt, pNdbOperationW, getValue(c_szWarehouseCount, 0));
  379.     for(Uint32 nDistrict=0; nDistrict<g_nDistrictPerWarehouse; ++nDistrict) {
  380.       NdbOperation* pNdbOperationD = NULL ;
  381.       VerifyMethodPtr(pNdbOperationD, pNdbConnection, getNdbOperation(c_szDistrict));
  382.       VerifyMethodInt(pNdbOperationD, readTuple());
  383.       VerifyMethodInt(pNdbOperationD, equal(c_szDistrictWarehouseNumber, nWarehouse));
  384.       VerifyMethodInt(pNdbOperationD, equal(c_szDistrictNumber, nDistrict));
  385.       VerifyMethodPtr(ppNdbRecAttrDSum[nDistrict], pNdbOperationD, getValue(c_szDistrictSum, 0));
  386.       VerifyMethodPtr(ppNdbRecAttrDCnt[nDistrict], pNdbOperationD, getValue(c_szDistrictCount, 0));
  387.     }
  388.     int iExec = pNdbConnection->execute(Commit);
  389.     int iError = pNdbConnection->getNdbError().code;
  390.     
  391.     if(iExec<0 && iError!=0 && iError!=266 && iError!=626) {
  392.       ReportMethodInt(iExec, pNdbConnection, "pNdbConnection", "execute(Commit)", __FILE__, __LINE__);
  393.     }
  394.     if(iExec==0) {
  395.       Uint32 nSum = 0;
  396.       Uint32 nCnt = 0;
  397.       for(Uint32 nDistrict=0; nDistrict<g_nDistrictPerWarehouse; ++nDistrict) {
  398.         nSum += ppNdbRecAttrDSum[nDistrict]->u_32_value();
  399.         nCnt += ppNdbRecAttrDCnt[nDistrict]->u_32_value();
  400.       }
  401.       if(nSum!=pNdbRecAttrWSum->u_32_value()
  402.          || nCnt!=g_nDistrictPerWarehouse*pNdbRecAttrWCnt->u_32_value()) {
  403.         ndbout << "INCONSISTENT!" << endl;
  404.         ndbout << "iExec==" << iExec << endl;
  405.         ndbout << "iError==" << iError << endl;
  406.         ndbout << endl;
  407.         ndbout << c_szWarehouseSum << "==" << pNdbRecAttrWSum->u_32_value() << ", ";
  408.         ndbout << c_szWarehouseCount << "==" << pNdbRecAttrWCnt->u_32_value() << endl;
  409.         ndbout << "nSum==" << nSum << ", nCnt=" << nCnt << endl;
  410.         for(Uint32 nDistrict=0; nDistrict<g_nDistrictPerWarehouse; ++nDistrict) {
  411.           ndbout << c_szDistrictSum << "[" << nDistrict << "]==" << ppNdbRecAttrDSum[nDistrict]->u_32_value() << ", ";
  412.           ndbout << c_szDistrictCount << "[" << nDistrict << "]==" << ppNdbRecAttrDCnt[nDistrict]->u_32_value() << endl;
  413.         }
  414.         VerifyMethodVoid(pNdb, closeTransaction(pNdbConnection));
  415.         delete pNdb; pNdb = NULL ;
  416.         delete[] ppNdbRecAttrDSum; ppNdbRecAttrDSum = NULL ;
  417.         delete[] ppNdbRecAttrDCnt; ppNdbRecAttrDCnt = NULL ;
  418.         NDBT_ProgramExit(NDBT_FAILED);
  419.       }
  420.       ++nSucc;
  421.     } else {
  422.       ++nFail;
  423.     }
  424.     VerifyMethodVoid(pNdb, closeTransaction(pNdbConnection));
  425.   }
  426.   ndbout << "read: " << nSucc << " succeeded, " << nFail << " failed " << endl;
  427.   NdbMutex_Unlock(g_pNdbMutex);
  428.   delete pNdb; pNdb = NULL ;
  429.   delete[] ppNdbRecAttrDSum; ppNdbRecAttrDSum = NULL ;
  430.   delete[] ppNdbRecAttrDCnt; ppNdbRecAttrDCnt = NULL ;
  431.   return NULL;
  432. }
  435. NDB_COMMAND(acid, "acid", "acid", "acid", 65535)
  436. {
  437.   ndb_init();
  438.   long nSeconds = 60;
  439.   int rc = NDBT_OK;
  441.   for(int i=1; i<argc; ++i) {
  442.     if(argv[i][0]=='-' || argv[i][0]=='/') {
  443.       switch(argv[i][1]) {
  444.       case 'w': g_nWarehouseCount=atol(argv[i]+2); break;
  445.       case 'd': g_nDistrictPerWarehouse=atol(argv[i]+2); break;
  446.       case 's': nSeconds=atol(argv[i]+2); break;
  447.       case 't': g_nThreadCount=atol(argv[i]+2); break;
  448.       default: ndbout << "invalid option" << endl; return 1;
  449.       }
  450.     } else {
  451.       ndbout << "invalid operand" << endl;
  452.       return 1;
  453.     }
  454.   }
  455.   ndbout << argv[0];
  456.   ndbout << " -w" << g_nWarehouseCount;
  457.   ndbout << " -d" << g_nDistrictPerWarehouse;
  458.   ndbout << " -s" << (int)nSeconds;
  459.   ndbout << " -t" << g_nThreadCount;
  460.   ndbout << endl;
  462.   Ndb* pNdb = NULL ;
  463.   pNdb = new Ndb("TEST_DB");
  464.   VerifyMethodInt(pNdb, init());
  465.   VerifyMethodInt(pNdb, waitUntilReady());
  467.   NdbSchemaCon* pNdbSchemaCon= NdbSchemaCon::startSchemaTrans(pNdb);
  468.   if(!pNdbSchemaCon){
  469.     ndbout <<"startSchemaTransaction failed, exiting now" << endl ;
  470.     delete pNdb ;
  471.     NDBT_ProgramExit(NDBT_FAILED) ;
  472.   }
  473.   NdbSchemaOp* pNdbSchemaOp = NULL ;
  474.   VerifyMethodPtr(pNdbSchemaOp, pNdbSchemaCon, getNdbSchemaOp());
  475. #if defined NDB_OSE || defined NDB_SOFTOSE
  476.   VerifyMethodInt(pNdbSchemaOp, createTable(
  477.                                             c_szWarehouse, 
  478.                                             (4+4+4+12)*1.02*g_nWarehouseCount/1024+1, 
  479.                                             TupleKey, 
  480.                                             (4+14)*g_nWarehouseCount/8/1024+1,
  481.                                             All, 
  482.                                             6,
  483.                                             78,
  484.                                             80,
  485.                                             1,
  486.                                             false));
  487. #else
  488.   VerifyMethodInt(pNdbSchemaOp, createTable(
  489.                                             c_szWarehouse, 
  490.                                             (4+4+4+12)*1.02*g_nWarehouseCount/1024+1, 
  491.                                             TupleKey, 
  492.                                             (4+14)*g_nWarehouseCount/8/1024+1));
  493. #endif
  494.   VerifyMethodInt(pNdbSchemaOp, createAttribute(c_szWarehouseNumber, TupleKey, 32, 1, UnSigned, MMBased, false));
  495.   VerifyMethodInt(pNdbSchemaOp, createAttribute(c_szWarehouseSum, NoKey, 32, 1, UnSigned, MMBased, false));
  496.   VerifyMethodInt(pNdbSchemaOp, createAttribute(c_szWarehouseCount, NoKey, 32, 1, UnSigned, MMBased, false));
  497.   VerifyMethodInt(pNdbSchemaCon, execute());
  498.   NdbSchemaCon::closeSchemaTrans(pNdbSchemaCon);
  500.   pNdbSchemaCon= NdbSchemaCon::startSchemaTrans(pNdb);
  501.   VerifyMethodPtr(pNdbSchemaOp, pNdbSchemaCon, getNdbSchemaOp());
  502. #if defined NDB_OSE || defined NDB_SOFTOSE
  503.   VerifyMethodInt(pNdbSchemaOp, createTable(
  504.                                             c_szDistrict, 
  505.                                             (4+4+4+4+12)*1.02*g_nWarehouseCount*g_nDistrictPerWarehouse/1024+1, 
  506.                                             TupleKey, 
  507.                                             (4+4+14)*g_nWarehouseCount*g_nDistrictPerWarehouse/8/1024+1,
  508.                                             All, 
  509.                                             6,
  510.                                             78,
  511.                                             80,
  512.                                             1,
  513.                                             false));
  514. #else
  515.   VerifyMethodInt(pNdbSchemaOp, createTable(
  516.                                             c_szDistrict, 
  517.                                             (4+4+4+4+12)*1.02*g_nWarehouseCount*g_nDistrictPerWarehouse/1024+1, 
  518.                                             TupleKey, 
  519.                                             (4+4+14)*g_nWarehouseCount*g_nDistrictPerWarehouse/8/1024+1));
  521. #endif
  522.   VerifyMethodInt(pNdbSchemaOp, createAttribute(c_szDistrictWarehouseNumber, TupleKey, 32, 1, UnSigned, MMBased, false));
  523.   VerifyMethodInt(pNdbSchemaOp, createAttribute(c_szDistrictNumber, TupleKey, 32, 1, UnSigned, MMBased, false));
  524.   VerifyMethodInt(pNdbSchemaOp, createAttribute(c_szDistrictSum, NoKey, 32, 1, UnSigned, MMBased, false));
  525.   VerifyMethodInt(pNdbSchemaOp, createAttribute(c_szDistrictCount, NoKey, 32, 1, UnSigned, MMBased, false));
  526.   VerifyMethodInt(pNdbSchemaCon, execute());
  527.   NdbSchemaCon::closeSchemaTrans(pNdbSchemaCon);
  528.   g_pNdbMutex = NdbMutex_Create();
  529.   NdbMutex_Lock(g_pNdbMutex);
  531.   NdbThread** ppNdbThread = new NdbThread*[g_nThreadCount*4];
  532.   for(Uint32 nThread=0; nThread<g_nThreadCount; ++nThread) {
  533.     ppNdbThread[nThread*4+0] = NdbThread_Create(NdbThreadFuncInsert, 0, 65535, "insert",
  534.                                                 NDB_THREAD_PRIO_LOW);
  535.     ppNdbThread[nThread*4+1] = NdbThread_Create(NdbThreadFuncUpdate, 0, 65535, "update",
  536.                                                 NDB_THREAD_PRIO_LOW);
  537.     ppNdbThread[nThread*4+2] = NdbThread_Create(NdbThreadFuncDelete, 0, 65535, "delete",
  538.                                                 NDB_THREAD_PRIO_LOW);
  539.     ppNdbThread[nThread*4+3] = NdbThread_Create(NdbThreadFuncRead, 0, 65535, "read",
  540.                                                 NDB_THREAD_PRIO_LOW);
  541.   }
  543.   NdbSleep_SecSleep(nSeconds);
  544.   NdbMutex_Unlock(g_pNdbMutex);
  546.   void* pStatus;
  547.   for(Uint32 nThread=0; nThread<g_nThreadCount; ++nThread) {
  548.     NdbThread_WaitFor(ppNdbThread[nThread*4+0], &pStatus);
  549.     NdbThread_WaitFor(ppNdbThread[nThread*4+1], &pStatus);      
  550.     NdbThread_WaitFor(ppNdbThread[nThread*4+2], &pStatus);      
  551.     NdbThread_WaitFor(ppNdbThread[nThread*4+3], &pStatus);      
  552.   }
  554.   NdbMutex_Destroy(g_pNdbMutex);
  555.   delete[] ppNdbThread;
  556.   delete pNdb;
  557.   return NDBT_ProgramExit(rc);
  558. }