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

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

MySQL数据库

开发平台：

Visual C++

flexScan.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. /* ***************************************************
  18.        FLEXSCAN
  19.        Perform benchmark of:
  20.          insert
  21.  read
  22.  scan read
  23.  update
  24.  scan update
  25.  read
  26.  scan delete
  27.  verify delete
  29.        Arguments:
  30.         -f Location of Ndb.cfg file, default Ndb.cfg
  31.         -t Number of threads to start, default 1
  32.         -o Number of operations per loop, default 500 -l Number of loops to run, default 1, 0=infinite
  33.         -a Number of attributes, default 25
  34.         -c Number of tables, default 1
  35. -s Size of each attribute, default 1
  36. -stdtables Use standard table names
  37.         -no_table_create Don't create tables in db
  38. -sleep Sleep a number of seconds before running the test, this 
  39.        can be used so that another flexBench hav etome to create tables
  40. -p Parallellism to use 1-32, default:1
  41. -abort <number> Test scan abort after a number of tuples
  42. -h Print help text
  43. -no_scan_update Don't do scan updates
  44. -no_scan_delete Don't do scan deletes
  46.        Returns:
  47.         NDBT_OK - Test passed
  48.         NDBT_FAILED - Test failed
  50.   Revision history:
  51.     1.12 020222 epesson: Rewritten to use NDBT. Major bugs fixed
  53.  * *************************************************** */
  55. #include "NdbApi.hpp"
  57. #include <NdbThread.h>
  58. #include <NdbSleep.h>
  59. #include <NdbTick.h>
  60. #include <NdbOut.hpp>
  61. #include <NdbTimer.hpp>
  62. #include <NdbMain.h>
  63. #include <NdbTest.hpp>
  64. #include <NDBT_Error.hpp>
  65. #include <NdbSchemaCon.hpp>
  67. #define PKSIZE 1
  68. #define FOREVER 1
  69. #define MAXSTRLEN 16 
  70. #define MAXATTR 64
  71. #define MAXTABLES 64
  72. #define MAXTHREADS 256
  73. #define MAXATTRSIZE 64
  75. enum StartType { 
  76.   stIdle, 
  77.   stInsert,
  78.   stRead, 
  79.   stScanRead,
  80.   stUpdate,
  81.   stScanUpdate,
  82.   stDelete,
  83.   stVerifyDelete, 
  84.   stScanDelete,
  85.   stStop,
  86.   stLast} ;
  89. struct ThreadNdb
  90. {
  91.   int ThreadNo;
  92.   NdbThread* threadLife;
  93.   StartType threadStart;
  94.   int threadResult;
  95.   int threadReady;
  96. };
  98. extern "C" void* flexScanThread(void*);
  99. static int setAttrNames(void);
  100. static int setTableNames(void);
  101. static int createTables(Ndb* pMyNdb);
  102. static void sleepBeforeStartingTest(int seconds);
  103. static int readArguments(int argc, const char** argv);
  104. static void setAttrValues(int* attrValue, 
  105.   int* readValue, 
  106.   int Offset);
  107. static int insertRows(Ndb* pNdb, int* pkValue, int* attrValue, StartType tType);
  108. static int readRows(Ndb* pNdb, int* pkValue, int* readValue);
  109. static int deleteRows(Ndb* pNdb, int* pkValue);
  110. static int scanReadRows(Ndb* pNdb, int* readValue);
  111. static int scanUpdateRows(Ndb* pNdb, int* readValue, int* attrValue);
  112. static int scanDeleteRows(Ndb* pNdb, int* readValue);
  113. static int verifyDeleteRows(Ndb* pNdb, int* pkValue, int* readValue);
  114. static void Compare(int* attrValue, int* readValue);
  115. static void UpdateArray(int *attrValue);
  117. static int tNoOfThreads = 1;
  118. static int tNoOfAttributes = 25;
  119. static int tNoOfTables = 1;
  120. static int tAttributeSize = 1;
  121. static int tNodeId = 0;
  122. static int tNoOfOperations = 500;
  123. static int tNoOfLoops = 1;
  124. static int tAbortAfter = 0;
  125. static int tParallellism = 1;
  127. static char tableName[MAXTABLES][MAXSTRLEN];
  128. static char attrName[MAXATTR][MAXSTRLEN];
  130. static unsigned int tSleepTime = 0;
  132. static int theStdTableNameFlag = 0;
  133. static int theTableCreateFlag = 0;
  134. static int theScanAbortTestFlag = 0;
  135. static int theNoScanUpdateFlag = 0;
  136. static int theNoScanDeleteFlag = 0;
  138. //flexScanErrorData = new ErrorData;
  139. ErrorData * flexScanErrorData;
  140. NdbError  * anerror;
  142. //static errorData            theErrorData; 
  143. //static unsigned int         tErrorCounter[6000]; 
  145. #define START_TIMER { NdbTimer timer; timer.doStart();
  146. #define STOP_TIMER timer.doStop();
  147. #define PRINT_TIMER(text, trans, opertrans) timer.printTransactionStatistics(text, trans, opertrans); }; 
  149. static void UpdateArray(int *attrValue)
  150. {
  151.   int tableCount = 0;
  152.   int attrCount = 0;
  153.   int opCount = 0;
  154.   int sizeCount = 0;
  155.   int* pValue = attrValue;
  157.   for (tableCount = 0; tableCount < tNoOfTables; tableCount++) {
  158.     for (attrCount = 0; attrCount < tNoOfAttributes-1; attrCount++) {
  159.       for (opCount = 0; opCount < tNoOfOperations; opCount++) {
  160. for (sizeCount = 0; sizeCount < tAttributeSize; sizeCount++) {
  161.   // Update value in array
  162.   (*pValue)++;
  163.   //ndbout << "attrValue[" << tableCount*tNoOfAttributes*tNoOfOperations*tAttributeSize +
  164.   //attrCount*tNoOfOperations*tAttributeSize + opCount*tAttributeSize + sizeCount <<
  165.   //"] = " << attrValue[tableCount*tNoOfAttributes*tNoOfOperations*tAttributeSize +
  166.   //attrCount*tNoOfOperations*tAttributeSize + opCount*tAttributeSize + sizeCount] << endl;
  167.   // Increment pointer
  168.   pValue++;
  169. } // sizeCount
  170.       } // for opCount
  171.     } // for attrCount
  172.   } // for tableCount
  174. } // Update
  176. static void Compare(int* attrValue, int* readValue)
  177. {
  178.   int tableCount = 0;
  179.   int attrCount = 0;
  180.   int OpCount = 0;
  181.   int first = 0;
  183.   for (tableCount = 0; tableCount < tNoOfTables; tableCount++) {
  184.     for (attrCount = 0; attrCount < tNoOfAttributes-1; attrCount++) {
  185.       for (OpCount = 0; OpCount < tNoOfOperations; OpCount++) {
  186. if (memcmp(&(attrValue[tableCount*(tNoOfAttributes-1)*tNoOfOperations + 
  187.       attrCount*tNoOfOperations + OpCount]),
  188.    &(readValue[tableCount*(tNoOfAttributes-1)*tNoOfOperations + 
  189.       attrCount*tNoOfOperations + OpCount]), 
  190.    tAttributeSize) != 0) {
  191.   // Values mismatch
  192.   if (first == 0) {
  193.     //ndbout << "Read and set values differ for:" << endl;
  194.     first = 1;
  195.     ndbout << "Mismatch found.";
  196.   } // if
  197.   // Comparision of values after scan update is meaningless right now
  198.   //ndbout << "  table " << tableName[tableCount] << 
  199.   //" - attr " << attrName[attrCount+1];
  200.   //for (sizeCount = 0; sizeCount < tAttributeSize; sizeCount++) {
  201.   //ndbout << ": set " << 
  202.   //attrValue[tableCount*(tNoOfAttributes-1)*tNoOfOperations*tAttributeSize + 
  203.   //attrCount*tNoOfOperations*tAttributeSize + 
  204.   //tNoOfOperations*tAttributeSize + sizeCount] << " read " << 
  205.   //readValue[tableCount*(tNoOfAttributes-1)*tNoOfOperations*tAttributeSize + 
  206.   //attrCount*tNoOfOperations*tAttributeSize + 
  207.   //tNoOfOperations*tAttributeSize + sizeCount] << endl;
  208.   //} // for
  209. } // if
  210.       } // for OpCount
  211.     } // for attrCount
  212.   } // for tableCount
  214.   // A final pretty-print
  215.   if (first == 1) {
  216.     ndbout << endl;
  217.   } // if
  218. } // Compare
  220. static void printInfo()
  221. {
  222.   ndbout << endl << "FLEXSCAN - Starting normal mode" << endl;
  223.   ndbout << "Perform benchmark of insert, update and delete transactions"<< endl;
  224.   ndbout << "  NdbAPI node with id = " << tNodeId << endl;
  225.   ndbout << "  " << tNoOfThreads << " thread(s) " << endl;
  226.   ndbout << "  " << tNoOfLoops << " iterations " << endl;
  227.   ndbout << "  " << tNoOfTables << " table(s) and " << 1 << " operation(s) per transaction " 
  228.  << endl;
  229.   ndbout << "  " << tNoOfAttributes << " attributes per table incl. pk" << endl;
  230.   ndbout << "  " << tNoOfOperations << " transaction(s) per thread and round " << endl;
  231.   if (theScanAbortTestFlag == 1) {
  232.     ndbout << "  Scan abort test after " << tAbortAfter << " tuples" << endl;
  233.   } // if
  234.   ndbout << "  " << tParallellism << " parallellism in scans" << endl;
  235.   ndbout << "  " << tAttributeSize << " is the number of 32 bit words per attribute " << 
  236.     endl << endl;
  237.   
  238. } // printInfo
  240. static void tellThreads(ThreadNdb *threadArrayP, StartType what)
  241. {
  242.   int i = 0;
  244.   for (i = 0; i < tNoOfThreads ; i++)
  245.     threadArrayP[i].threadStart = what;
  246. } // tellThreads
  248. static void waitForThreads(ThreadNdb *threadArrayP)
  249. {
  250.   int i = 0;
  251.   int cont = 1;
  253.   while (cont == 1){
  255.     NdbSleep_MilliSleep(10);
  256.     cont = 0;
  257.     
  258.     for (i = 0; i < tNoOfThreads ; i++) {
  259.       if (threadArrayP[i].threadReady == 0) {
  260. // ndbout << "Main is reporting thread " << i << " not ready" << endl;
  261. cont = 1;
  262.       } // if
  263.     } // for
  264.   } // while
  265. } // waitForThreads
  268. static void resetThreads(ThreadNdb *threadArrayP)
  269. {
  270.   int i = 0;
  272.   for (i = 0; i < tNoOfThreads ; i++) {
  273.     threadArrayP[i].threadReady = 0;
  274.     threadArrayP[i].threadResult = 0;
  275.     threadArrayP[i].threadStart = stIdle;
  276.     //ndbout << "threadStart[" << i << "]=" << 
  277.     //threadArrayP[i].threadStart << endl;
  278.   } // for
  279. } // resetThreads
  281. static int checkThreadResults(ThreadNdb *threadArrayP, char *action)
  282. {
  283.   int i = 0;
  284.   int retValue = 0;
  286.   for (i = 0; i < tNoOfThreads; i++) {
  287.     if (threadArrayP[i].threadResult != 0) {
  288.       ndbout << "Thread " << i << " reported fatal error " 
  289.      << threadArrayP[i].threadResult << " during " << action << endl;
  290.       retValue = -1;
  291.       break;
  292.     } // if
  293.   } // for
  295.   return(retValue);
  296. } // checkThreadResults
  298. NDB_COMMAND(flexScan, "flexScan", "flexScan", "flexScan", 65535)
  299. {
  300.   ndb_init();
  301.   ThreadNdb* pThreads = NULL;
  302.   Ndb* pMyNdb = NULL;
  303.   int                   tLoops = 0;
  304.   int                   check = 0;
  305.   int                   returnValue = NDBT_OK;
  306.   int                   every2ndScanDelete = 0; // Switch between scan delete and normal delete
  308.   flexScanErrorData = new ErrorData;
  310.   flexScanErrorData->resetErrorCounters();
  312.   if (readArguments(argc, argv) != 0) {
  313.     ndbout << "Wrong arguments to flexScan" << endl;
  314.     return NDBT_ProgramExit(NDBT_WRONGARGS);
  315.   } // if
  317.   /* print Setting */
  318.   flexScanErrorData->printSettings(ndbout);
  320.   check = setAttrNames();
  321.   if (check != 0) {
  322.     ndbout << "Couldn't set attribute names" << endl;
  323.     return NDBT_ProgramExit(NDBT_FAILED);
  324.   } // if
  325.   check = setTableNames();
  326.   if (check != 0) {
  327.     ndbout << "Couldn't set table names" << endl;
  328.     return NDBT_ProgramExit(NDBT_FAILED);
  329.   } // if
  331.   pMyNdb = new Ndb ("TEST_DB");
  332.   pMyNdb->init();
  333.   tNodeId = pMyNdb->getNodeId();
  335.   printInfo();
  336.                                   
  337.   NdbThread_SetConcurrencyLevel(tNoOfThreads + 2);
  338.   //NdbThread_SetConcurrencyLevel(tNoOfThreads + 8);
  339.   
  340.   pThreads = new ThreadNdb[tNoOfThreads];
  342.   if (pMyNdb->waitUntilReady(10000) != 0) {
  343.     ndbout << "NDB is not ready" << endl << "Benchmark failed"  << endl;
  344.     returnValue = NDBT_FAILED;
  345.   } // if
  346.   
  347.   else {
  348.     
  349.     if (createTables(pMyNdb) != 0) {
  350.       ndbout << "Could not create tables" << endl;
  351.       returnValue = NDBT_FAILED;
  352.     } // if
  353.     else {
  354.       sleepBeforeStartingTest(tSleepTime);
  355.       
  356.       resetThreads(pThreads);
  357.       // Create threads
  358.       for (int i = 0; i < tNoOfThreads ; i++){  
  359. pThreads[i].ThreadNo = i;
  360. // Ignore the case that thread creation may fail
  361. pThreads[i].threadLife = NdbThread_Create(flexScanThread,
  362.   (void**)&pThreads[i],
  363.   327680,
  364.   "flexScanThread", NDB_THREAD_PRIO_LOW);
  365. if (pThreads[i].threadLife == NULL) {
  366.   ndbout << "Could not create thread " << i << endl;
  367.   returnValue = NDBT_FAILED;
  368.   // Use the number of threads that were actually created
  369.   tNoOfThreads = i;
  370.   break; // break for loop
  371. } // if
  372.       } // for
  373.       
  374.       waitForThreads(pThreads);
  375.       if (checkThreadResults(pThreads, "init") != 0) {
  376. returnValue = NDBT_FAILED;
  377.       } // if
  378.       
  379.       if (returnValue == NDBT_OK) {
  380. ndbout << "All threads started" << endl;
  382. while (FOREVER) {
  383.   
  384.   resetThreads(pThreads);
  385.   
  386.   if ((tNoOfLoops != 0) && (tNoOfLoops <= tLoops)) {
  387.     break;
  388.   } // if
  389.   
  390.   // Insert
  391.   START_TIMER;
  392.   
  393.   tellThreads(pThreads, stInsert);
  394.   waitForThreads(pThreads);
  395.   
  396.   STOP_TIMER;
  397.   if (checkThreadResults(pThreads, "insert") != 0) {
  398.     returnValue = NDBT_FAILED;
  399.     break;
  400.   } // if
  401.   PRINT_TIMER("insert", tNoOfOperations*tNoOfThreads, tNoOfTables);
  402.   
  403.   resetThreads(pThreads);
  404.   
  405.   // Read
  406.   START_TIMER;
  407.   
  408.   tellThreads(pThreads, stRead);
  409.   waitForThreads(pThreads);
  410.   
  411.   STOP_TIMER;
  412.   if (checkThreadResults(pThreads, "read") != 0) {
  413.     returnValue = NDBT_FAILED;
  414.     break;
  415.   } // if
  416.   PRINT_TIMER("read", tNoOfOperations*tNoOfThreads, tNoOfTables);
  417.   
  418.   resetThreads(pThreads);
  419.   
  420.   // Update
  421.   START_TIMER;
  422.   
  423.   tellThreads(pThreads, stUpdate);
  424.   waitForThreads(pThreads);
  425.   
  426.   STOP_TIMER;
  427.   if (checkThreadResults(pThreads, "update") != 0) {
  428.     returnValue = NDBT_FAILED;
  429.     break;
  430.   } // if
  431.   PRINT_TIMER("update", tNoOfOperations*tNoOfThreads, tNoOfTables);
  432.   
  433.   resetThreads(pThreads);
  434.   
  435.   // Scan read
  436.   START_TIMER;
  437.   
  438.   tellThreads(pThreads, stScanRead);
  439.   waitForThreads(pThreads);
  440.   
  441.   STOP_TIMER;
  442.   if (checkThreadResults(pThreads, "scanread") != 0) {
  443.     returnValue = NDBT_FAILED;
  444.     break;
  445.   } // if
  446.   PRINT_TIMER("scanread", tNoOfTables*tNoOfThreads, 1);
  447.   
  448.   resetThreads(pThreads);
  449.   
  450.   // Update
  451.   START_TIMER;
  452.   
  453.   tellThreads(pThreads, stUpdate);
  454.   waitForThreads(pThreads);
  455.   
  456.   STOP_TIMER;
  457.   if (checkThreadResults(pThreads, "update") != 0) {
  458.     returnValue = NDBT_FAILED;
  459.     break;
  460.   } // if
  461.   PRINT_TIMER("update", tNoOfOperations*tNoOfThreads, tNoOfTables);
  462.   
  463.   resetThreads(pThreads);
  464.   
  465.   // Read
  466.   START_TIMER;
  467.   
  468.   tellThreads(pThreads, stRead);
  469.   waitForThreads(pThreads);
  470.   
  471.   STOP_TIMER;
  472.   if (checkThreadResults(pThreads, "read") != 0) {
  473.     returnValue = NDBT_FAILED;
  474.     break;
  475.   } // if
  476.   PRINT_TIMER("read", tNoOfOperations*tNoOfThreads, tNoOfTables);
  477.   
  478.   resetThreads(pThreads);
  479.   
  480.   // Only do scan update if told to do so
  481.   if (theNoScanUpdateFlag == 0) {
  482.     // Scan update
  483.     START_TIMER;
  484.     
  485.     tellThreads(pThreads, stScanUpdate);
  486.     waitForThreads(pThreads);
  487.     
  488.     STOP_TIMER;
  489.     if (checkThreadResults(pThreads, "scanupdate") != 0) {
  490.       returnValue = NDBT_FAILED;
  491.       break;
  492.     } // if
  493.     PRINT_TIMER("scanupdate", tNoOfTables*tNoOfThreads, 1);
  494.     
  495.     resetThreads(pThreads);
  496.     
  497.     // Read
  498.     START_TIMER;
  499.     
  500.     tellThreads(pThreads, stRead);
  501.     // tellThreads(pThreads, stScanRead);
  502.     waitForThreads(pThreads);
  503.     
  504.     STOP_TIMER;
  505.     if (checkThreadResults(pThreads, "read") != 0) {
  506.       returnValue = NDBT_FAILED;
  507.       break;
  508.     } // if
  509.     PRINT_TIMER("read", tNoOfOperations*tNoOfThreads, tNoOfTables);
  510.     
  511.     resetThreads(pThreads);
  512.   } // if theNoScanUpdateFlag
  514.   // Shift between delete and scan delete
  515.   if ((every2ndScanDelete % 2 == 0) || (theNoScanDeleteFlag == 1)){
  516.     // Delete
  517.     START_TIMER;
  518.     tellThreads(pThreads, stDelete);
  519.     waitForThreads(pThreads);
  520.     
  521.     STOP_TIMER;
  522.     if (checkThreadResults(pThreads, "delete") != 0) {
  523.       returnValue = NDBT_FAILED;
  524.       break;
  525.     } // if
  526.     PRINT_TIMER("delete", tNoOfOperations*tNoOfThreads, tNoOfTables);
  527.     resetThreads(pThreads);
  528.   } // if
  529.   else {
  530.     resetThreads(pThreads);   // Scan delete
  531.     START_TIMER;
  532.     tellThreads(pThreads, stScanDelete);
  533.     waitForThreads(pThreads);
  534.     
  535.     STOP_TIMER;
  536.     if (checkThreadResults(pThreads, "scandelete") != 0) {
  537.       returnValue = NDBT_FAILED;
  538.       break;
  539.     } // if
  540.     PRINT_TIMER("scandelete", tNoOfTables*tNoOfThreads, 1);
  541.     
  542.     resetThreads(pThreads);
  543.   } // else
  544.   every2ndScanDelete++;
  546.   resetThreads(pThreads);   // Verify delete
  547.   START_TIMER;
  548.   tellThreads(pThreads, stVerifyDelete);
  549.   waitForThreads(pThreads);
  550.   
  551.   STOP_TIMER;
  552.   if (checkThreadResults(pThreads, "verifydelete") != 0) {
  553.     returnValue = NDBT_FAILED;
  554.     break;
  555.   } // if
  556.   PRINT_TIMER("verifydelete", tNoOfOperations*tNoOfThreads*tNoOfTables, 1);
  557.   
  558.   resetThreads(pThreads);
  559.   
  560.   ndbout << "--------------------------------------------------" << endl;
  561.   tLoops++;
  562.   
  563. } // while
  564.       } // if
  565.     } // else
  566.   } // else
  568.   // Stop threads in a nice way
  569.   tellThreads(pThreads, stStop);
  570.   waitForThreads(pThreads);
  572.   // Clean up
  573.   delete [] pThreads;
  574.   delete pMyNdb;
  576.   flexScanErrorData->printErrorCounters(ndbout);
  578.   if (returnValue == NDBT_OK) {
  579.     ndbout << endl << "Benchmark completed successfully" << endl;
  580.   } // if
  581.   else {
  582.     ndbout << endl << "Benchmark failed" << endl;
  583.   } // else
  585.   // Exit via NDBT
  586.   return NDBT_ProgramExit(returnValue);;
  587. } // main
  589. void*
  590. flexScanThread(void* ThreadData)
  591. {
  592.   ThreadNdb* pThreadData = (ThreadNdb*)ThreadData;
  593.   unsigned int thread_no = pThreadData->ThreadNo;
  594.   unsigned int thread_base = (thread_no * 2000000) + (tNodeId * 26000);
  595.   int tThreadResult = 0;
  596.   Ndb* MyNdb = NULL;
  597.   int                   check = 0;
  598.   StartType        tType = stLast;
  599.   int*                  pkValue = NULL;
  600.   int* attrValue = NULL;
  601.   int* readValue = NULL;
  602.   int                   AllocSize = 0;
  603.   
  604.   AllocSize = tNoOfTables * (tNoOfAttributes-1) * tNoOfOperations * 
  605.     tAttributeSize * sizeof(int);
  606.   attrValue = (int*)malloc(AllocSize);
  607.   readValue = (int*)malloc(AllocSize);
  608.   pkValue = (int*)malloc(tNoOfOperations * sizeof(int));
  609.   if ((attrValue == NULL) || (readValue == NULL) || (pkValue == NULL)) {
  610.     tThreadResult = 98;
  611.     pThreadData->threadStart = stIdle;
  612.   } // if
  613.   
  614.   setAttrValues(attrValue, readValue, thread_base);
  615.   
  616.   MyNdb = new Ndb( "TEST_DB" );
  617.   MyNdb->init();
  618.   if (MyNdb->waitUntilReady(10000) != 0) {
  619.     tThreadResult = 99;
  620.     pThreadData->threadStart = stIdle;
  621.   } // if
  622.   
  623.   // Set primary key value, same for all tables
  624.   for (int c = 0; c < tNoOfOperations; c++) {
  625.     pkValue[c] = (int)(c + thread_base);
  626.   } // for
  627.   
  628.   while (FOREVER) {
  629.     pThreadData->threadResult = tThreadResult;
  630.     pThreadData->threadReady = 1;
  631.     
  632.     while (pThreadData->threadStart == stIdle) {
  633.       NdbSleep_MilliSleep(10);
  634.     } // while
  635.     
  636.     // Check if signal to exit is received
  637.     if (pThreadData->threadStart >= stStop){
  638.       pThreadData->threadReady = 1;
  639.       break;
  640.     } // if
  641.     tType = pThreadData->threadStart;
  642.     pThreadData->threadStart = stIdle;
  643.     
  644.     switch (tType) {
  645.     case stInsert:
  646.       check = insertRows(MyNdb, pkValue, attrValue, tType);
  647.       break;
  648.     case stRead:
  649.       check = readRows(MyNdb, pkValue, readValue);
  650.       Compare(attrValue, readValue);
  651.       break;
  652.     case stUpdate:
  653.       UpdateArray(attrValue);
  654.       check = insertRows(MyNdb, pkValue, attrValue, tType);
  655.       break;
  656.     case stScanRead:
  657.       //check = readRows(MyNdb, pkValue, readValue);
  658.       check = scanReadRows(MyNdb, readValue);
  659.       Compare(attrValue, readValue);
  660.       break;
  661.     case stScanUpdate:
  662.       UpdateArray(attrValue);
  663.       //tType = stUpdate;
  664.       //check = insertRows(MyNdb, pkValue, attrValue, tType);
  665.       check = scanUpdateRows(MyNdb, readValue, attrValue);
  666.       break;
  667.     case stDelete:
  668.       check = deleteRows(MyNdb, pkValue);
  669.       break;
  670.     case stScanDelete:
  671.       check = scanDeleteRows(MyNdb, readValue);
  672.       break;
  673.     case stVerifyDelete:
  674.       check = verifyDeleteRows(MyNdb, pkValue, readValue);
  675.       break;
  676.     default:
  677.       ndbout << "tType is " << tType << endl;
  678.       assert(false);
  679.       break;
  680.     } // switch
  681.     
  682.     tThreadResult = check;
  683.     
  684.     if (tThreadResult != 0) {
  685.       // Check if error is fatak or not
  686.     } // if
  687.     else {
  688.       continue;
  689.     } // else
  690.   } // while
  692.   // Clean up
  693.   delete MyNdb;
  694.   if (attrValue != NULL) {
  695.     free(attrValue);
  696.   } //if
  697.   if (readValue != NULL) {
  698.     free(readValue);
  699.   } // if
  700.   if (pkValue != NULL) {
  701.     free(pkValue);
  702.   } // if
  703.   
  704.   return NULL; // thread exits
  706. } // flexScanThread
  709. static int setAttrNames()
  710. {
  711.   int i = 0;
  712.   int  retVal = 0;
  713.   
  714.   for (i = 0; i < MAXATTR ; i++) {
  715.     retVal = BaseString::snprintf(attrName[i], MAXSTRLEN, "COL%d", i);
  716.     if (retVal < 0) {
  717.       return(-1);
  718.     } // if
  719.   } // for
  721.   return(0);
  722. } // setAttrNames
  725. static int setTableNames()
  726. {
  727.   // Note! Uses only uppercase letters in table name's
  728.   // so that we can look at the tables with SQL
  729.   int i = 0;
  730.   int retVal = 0;
  732.   for (i = 0; i < MAXTABLES ; i++) {
  734.     if (theStdTableNameFlag == 0) {
  735.       retVal = BaseString::snprintf(tableName[i], MAXSTRLEN, "TAB%d_%d", i, 
  736.        (int)(NdbTick_CurrentMillisecond() / 1000));
  737.     } // if 
  738.     else {
  739.       retVal = BaseString::snprintf(tableName[i], MAXSTRLEN, "TAB%d", i);
  740.     } // if else
  742.     if (retVal < 0) {
  743.       return(-1);
  744.     } // if
  745.   } // for
  747.   return(0);
  748. } // setTableNames
  751. // Create Table and Attributes. 
  752. static int createTables(Ndb* pMyNdb)
  753. {
  754.   
  755.   NdbSchemaCon *MySchemaTransaction = NULL;
  756.   NdbSchemaOp *MySchemaOp = NULL;
  757.   int i = 0;
  758.   int j = 0;
  759.   int check = 0;
  760.   
  761.   if (theTableCreateFlag == 0) {
  762.     
  763.     i = 0;
  764.     do {
  765.       i++;
  766.       ndbout << endl << "Creating " << tableName[i - 1] << "..." << endl;
  768.       MySchemaTransaction = NdbSchemaCon::startSchemaTrans(pMyNdb);      
  769.       if( MySchemaTransaction == NULL ) {
  770. return (-1);
  771.       } // if
  773.       MySchemaOp = MySchemaTransaction->getNdbSchemaOp();
  774.       if( MySchemaOp == NULL ) {
  775. NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
  776. return (-1);
  777.       } // if
  779. #if defined NDB_OSE || defined NDB_SOFTOSE
  780.       check = MySchemaOp->createTable(tableName[i - 1],
  781.       8, // Table Size
  782.       TupleKey,         // Key Type
  783.       40, // Nr of Pages
  784.       All,
  785.       6,
  786.       78,
  787.       80,
  788.       1,
  789.       false);
  790. #else
  791.       check = MySchemaOp->createTable(tableName[i - 1]
  792.       ,8 // Table Size
  793.       ,TupleKey         // Key Type
  794.       ,40); // Nr of Pages
  795. #endif      
  796.       if (check == -1) {
  797. NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
  798. return -1;
  799.       } // if
  800.       
  801.       check = MySchemaOp->createAttribute( (char*)attrName[0], TupleKey, 32, PKSIZE,
  802.    UnSigned, MMBased, NotNullAttribute );
  803.       if (check == -1) {
  804. NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
  805. return -1;
  806.       } // if
  807.       
  808.       for (j = 1; j < tNoOfAttributes ; j++) {
  809. check = MySchemaOp->createAttribute( (char*)attrName[j], NoKey, 32, tAttributeSize,
  810.      UnSigned, MMBased, NotNullAttribute );
  811. if (check == -1) {
  812.   NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
  813.   return -1;
  814. } // if
  815.       } // for
  816.       
  817.       if (MySchemaTransaction->execute() == -1) {
  818. ndbout <<  MySchemaTransaction->getNdbError().message << endl;
  819. ndbout << "Probably, " << tableName[i - 1] << " already exist" << endl;
  820.       } // if
  821.       
  822.       NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
  823.     } while (tNoOfTables > i);
  824.   }
  826.   return 0;
  827. } // createTables
  829. static void printUsage()
  830. {
  831.   ndbout << "Usage of flexScan:" << endl;
  832.   ndbout << "-f <path> Location of Ndb.cfg file, default: Ndb.cfg" << endl;
  833.   ndbout << "-t <int>  Number of threads to start, default 1" << endl;
  834.   ndbout << "-o <int>  Number of operations per loop, default 500" << endl;
  835.   ndbout << "-l <int>  Number of loops to run, default 1, 0=infinite" << endl;
  836.   ndbout << "-a <int>  Number of attributes, default 25" << endl;
  837.   ndbout << "-c <int>  Number of tables, default 1" << endl;
  838.   ndbout << "-s <int>  Size of each attribute, default 1" << endl;
  839.   ndbout << "-stdtables        Use standard table names" << endl;
  840.   ndbout << "-no_table_create  Don't create tables in db" << endl;
  841.   ndbout << "-sleep <int>      Sleep a number of seconds before running the test" << endl;
  842.   ndbout << "-p <int>          Parallellism to use 1-32, default:1" << endl;
  843.   ndbout << "-abort <int>      Test scan abort after a number of tuples" << endl;
  844.   ndbout << "-no_scan_update   Don't do scan updates" << endl;
  845.   ndbout << "-no_scan_delete   Don't do scan deletes" << endl;
  846.   ndbout << "-h                Print this text" << endl;
  847.   //  inputErrorArg();
  848.   flexScanErrorData->printCmdLineArgs(ndbout);
  849. }
  851. static int readArguments(int argc, const char** argv)
  852. {
  853.   int i = 1;
  854.   int retValue = 0;
  855.   int printFlag = 0;
  857.   tNoOfThreads = 1; // Set default Value
  858.   tNoOfTables = 1; // Default Value
  860.   while (argc > 1) {
  861.     if (strcmp(argv[i], "-t") == 0) {
  862.       if (argv[i + 1] != NULL) {
  863. tNoOfThreads = atoi(argv[i + 1]);
  864. if ((tNoOfThreads < 1) || (tNoOfThreads > MAXTHREADS)) {
  865.   retValue = -1;
  866. } // if
  867.       } // if
  868.       else {
  869. retValue = -1;
  870.       } // else
  871.     } // if
  872.     else if (strcmp(argv[i], "-o") == 0) {
  873.       if (argv[i + 1] != NULL) {
  874. tNoOfOperations = atoi(argv[i + 1]);
  875. if (tNoOfOperations < 1) {
  876.   retValue = -1;
  877. } // if
  878.       } // if
  879.       else {
  880. retValue = -1;
  881.       } // else
  882.     } // else if
  883.     else if (strcmp(argv[i], "-a") == 0) {
  884.       if (argv[i + 1] != NULL) {
  885. tNoOfAttributes = atoi(argv[i + 1]);
  886. if ((tNoOfAttributes < 2) || (tNoOfAttributes > MAXATTR)) {
  887.   retValue = -1;
  888. } // if
  889.       } // if
  890.       else {
  891. retValue = -1;
  892.       } // else
  893.     } // else if
  894.     else if (strcmp(argv[i], "-c") == 0) {
  895.       if (argv[i + 1] != NULL) {
  896. tNoOfTables = atoi(argv[i+1]);
  897. if ((tNoOfTables < 1) || (tNoOfTables > MAXTABLES)) {
  898.   retValue = -1;
  899. } // if
  900.       } // if
  901.       else {
  902. retValue = -1;
  903.       } // else
  904.     } // else if
  905.     else if (strcmp(argv[i], "-l") == 0) {
  906.       if (argv[i + 1] != NULL) {
  907. tNoOfLoops = atoi(argv[i+1]);
  908. if ((tNoOfLoops < 0) || (tNoOfLoops > 100000)) {
  909.   retValue = -1;
  910. } // if
  911.       } // if
  912.       else {
  913. retValue = -1;
  914.       } // else
  915.     } // else if
  916.     else if (strcmp(argv[i], "-s") == 0) {
  917.       if (argv[i + 1] != NULL) {
  918. tAttributeSize = atoi(argv[i+1]);
  919. if ((tAttributeSize < 1) || (tAttributeSize > MAXATTRSIZE)) {
  920.   retValue = -1;
  921. } // if
  922.       } // if
  923.       else {
  924. retValue = -1;
  925.       } // else
  926.     } // else if
  927.     else if (strcmp(argv[i], "-no_table_create") == 0) {
  928.       theTableCreateFlag = 1;
  929.       argc++;
  930.       i--;
  931.     } // else if
  932.     else if (strcmp(argv[i], "-stdtables") == 0) {
  933.       theStdTableNameFlag = 1;
  934.       argc++;
  935.       i--;
  936.     } // else if
  937.     else if (strcmp(argv[i], "-sleep") == 0) {
  938.       if (argv[i + 1] != NULL) {
  939. tSleepTime = atoi(argv[i+1]);
  940. if ((tSleepTime < 1) || (tSleepTime > 3600)) {
  941.   retValue = -1;
  942. } // if
  943.       } // if
  944.       else {
  945. retValue = -1;
  946.       } // else
  947.     } // else if
  948.     else if (strcmp(argv[i], "-abort") == 0) {
  949.       // Test scan abort after a number of tuples
  950.       theScanAbortTestFlag = 1;
  951.       if (argv[i + 1] != NULL) {
  952. tAbortAfter = atoi(argv[i + 1]);
  953.       } // if
  954.       else {
  955. retValue = -1;
  956.       } // else
  957.     } // else if
  958.     else if (strcmp(argv[i], "-p") == 0) {
  959.       if (argv[i + 1] != NULL) {
  960. tParallellism = atoi(argv[i + 1]);
  961. if ((tParallellism < 1) || (tParallellism > 32)) {
  962.   retValue = -1;
  963. } // if
  964.       } // if
  965.       else {
  966. retValue = -1;
  967.       } // else
  968.     } // else if
  969.     else if (strcmp(argv[i], "-h") == 0) {
  970.       printFlag = 1;
  971.       argc++;
  972.       i--;
  973.     } // else if
  974.     else if (strcmp(argv[i], "-no_scan_update") == 0) {
  975.       theNoScanUpdateFlag = 1;
  976.       argc++;
  977.       i--;
  978.     } // else if
  979.     else if (strcmp(argv[i], "-no_scan_delete") == 0) {
  980.       theNoScanDeleteFlag = 1;
  981.       argc++;
  982.       i--;
  983.     } // else if
  984.     else {
  985.       retValue = -1;
  986.     } // else
  988.     argc -= 2;
  989.     i = i + 2;
  990.   }
  992.   if ((retValue != 0) || (printFlag == 1)) {
  993.     printUsage();
  994.   } // if
  996.   return(retValue);
  997.   
  998. } // readArguments
  1000. static void sleepBeforeStartingTest(int seconds)
  1001. {
  1002.   if (seconds > 0) {
  1003.     ndbout << "Sleeping(" <<seconds << ")...";
  1004.     NdbSleep_SecSleep(seconds);
  1005.     ndbout << " done!" << endl;
  1006.   } // if
  1007. } // sleepBeforeStartingTest
  1009. static void setAttrValues(int* attrValue, 
  1010.   int* readValue, 
  1011.   int Offset)
  1012. {
  1013.   int tableCount = 0;
  1014.   int attrCount = 0;
  1015.   int OpCount = 0;
  1016.   int attrSize = 0;
  1017.   int* pAttr = NULL;
  1018.   int* pRead = NULL;
  1019.   
  1020.   // Set attribute values in memory array
  1021.   for (tableCount = 0; tableCount < tNoOfTables; tableCount++) {
  1022.     for (attrCount = 0; attrCount < tNoOfAttributes-1; attrCount++) { 
  1023.       for (OpCount = 0; OpCount < tNoOfOperations; OpCount++) {
  1024. pAttr = &(attrValue[tableCount*(tNoOfAttributes-1)*tNoOfOperations + 
  1025.    attrCount*tNoOfOperations + OpCount]);
  1026. pRead = &(readValue[tableCount*(tNoOfAttributes-1)*tNoOfOperations + 
  1027.    attrCount*tNoOfOperations + OpCount]);
  1028. for (attrSize = 0; attrSize < tAttributeSize; attrSize++){ 
  1029.   *pAttr = (int)(Offset + tableCount + attrCount + OpCount + attrSize);
  1030.   //ndbout << "attrValue[" << tableCount*(tNoOfAttributes-1)*tNoOfOperations + 
  1031.   //attrCount*tNoOfOperations + OpCount + attrSize << "] = " <<
  1032.   //attrValue[tableCount*(tNoOfAttributes-1)*tNoOfOperations + 
  1033.   //attrCount*tNoOfOperations + OpCount + attrSize] << endl;
  1034.   *pRead = 0;
  1035.   pAttr++;
  1036.   pRead++;
  1037. } // for attrSize
  1038.       } // for OpCount
  1039.     } // for attrCount
  1040.   } // for tableCount
  1041.   
  1042. } // setAttrValues
  1044. static int insertRows(Ndb* pNdb, // NDB object
  1045.       int* pkValue, // Primary key values
  1046.       int* attrValue, // Attribute values
  1047.       StartType tType)
  1048. {
  1049.   int tResult = 0;
  1050.   int check = 0;
  1051.   int tableCount = 0;
  1052.   int attrCount = 0;
  1053.   NdbConnection* MyTransaction = NULL;
  1054.   NdbOperation* MyOperations[MAXTABLES] = {NULL};
  1055.   int opCount = 0;
  1056.   
  1057.   for (opCount = 0; opCount < tNoOfOperations; opCount++) {
  1058.     MyTransaction = pNdb->startTransaction();
  1059.     if (MyTransaction == NULL) {
  1060.       tResult = 1;
  1061.     } // if
  1062.     else {
  1063.       for (tableCount = 0; tableCount < tNoOfTables; tableCount++) {
  1065. MyOperations[tableCount] = 
  1066.   MyTransaction->getNdbOperation(tableName[tableCount]);
  1067. if (MyOperations[tableCount] == NULL) {
  1068.   tResult = 2;
  1069.   // Break for tableCount loop
  1070.   break;
  1071. } // if
  1073. if (tType == stUpdate) {
  1074.   check = MyOperations[tableCount]->updateTuple();
  1075. } // if
  1076. else if (tType == stInsert) {
  1077.   check = MyOperations[tableCount]->insertTuple();
  1078. } // else if
  1079. else {
  1080.   assert(false);
  1081. } // else
  1083. if (check == -1) {
  1084.   tResult = 3;
  1085.   break;
  1086. } // if 
  1087. check = MyOperations[tableCount]->equal((char*)attrName[0], 
  1088. (char*)&(pkValue[opCount]));
  1089. if (check == -1) {
  1090.   tResult = 7;
  1091.   break;
  1092. } // if
  1094. for (attrCount = 0; attrCount < tNoOfAttributes - 1; attrCount++) {
  1095.   int Index = tableCount * (tNoOfAttributes - 1) * tNoOfOperations * tAttributeSize +
  1096.     attrCount * tNoOfOperations * tAttributeSize + opCount * tAttributeSize;
  1097.   check = MyOperations[tableCount]->
  1098.     setValue((char*)attrName[attrCount + 1],
  1099.      (char*)&(attrValue[Index]));
  1100.   if (check == -1) {
  1101.     tResult = 8;
  1102.     break; // break attrCount loop
  1103.   } // if
  1104. } // for
  1105.       } // for tableCount
  1106.       
  1107.       // Execute transaction with insert one tuple in every table
  1108.       check = MyTransaction->execute(Commit);
  1109.       if (check == -1) {
  1110. ndbout << MyTransaction->getNdbError().message << endl;
  1112. // Add complete error handling here
  1114.               int retCode = flexScanErrorData->handleErrorCommon(MyTransaction->getNdbError());
  1115.               if (retCode == 1) {
  1116. if (MyTransaction->getNdbError().code != 626 && MyTransaction->getNdbError().code != 630){
  1117.                 ndbout_c("execute: %d, %d, %s", opCount, tType, MyTransaction->getNdbError().message);
  1118.                 ndbout_c("Error code = %d", MyTransaction->getNdbError().code);}
  1119.                 tResult = 20;
  1120.               } else if (retCode == 2) {
  1121.                 ndbout << "4115 should not happen in flexBench" << endl;
  1122.                 tResult = 20;
  1123.               } else if (retCode == 3) {
  1124. // --------------------------------------------------------------------
  1125. // We are not certain if the transaction was successful or not.
  1126. // We must reexecute but might very well find that the transaction
  1127. // actually was updated. Updates and Reads are no problem here. Inserts
  1128. // will not cause a problem if error code 630 arrives. Deletes will
  1129. // not cause a problem if 626 arrives.
  1130. // --------------------------------------------------------------------
  1131. /* What can we do here? */
  1132.                 ndbout_c("execute: %s", MyTransaction->getNdbError().message);
  1133.                  }//if(retCode == 3)
  1135.       } // if(check == -1)
  1136.       
  1137.       pNdb->closeTransaction(MyTransaction);
  1138.     } // else
  1139.   } // for opCount
  1140.   
  1141.   return(tResult);
  1142. } // insertRows
  1144. static int readRows(Ndb* pNdb,
  1145.     int* pkValue,
  1146.     int* readValue)
  1147. {
  1148.   int tResult = 0;
  1149.   int tableCount = 0;
  1150.   int attrCount = 0;
  1151.   int check = 0;
  1152.   NdbConnection* MyTransaction = NULL;
  1153.   NdbOperation* MyOperations[MAXTABLES] = {NULL};
  1154.   NdbRecAttr* tmp = NULL;
  1155.   int Value = 0;
  1156.   int Index = 0;
  1157.   int opCount = 0;
  1159.   for (opCount = 0; opCount < tNoOfOperations; opCount++) {
  1160.     MyTransaction = pNdb->startTransaction();
  1161.     if (MyTransaction == NULL) {
  1162.       tResult = 1;
  1163.     } // if
  1164.     else {
  1165.       for (tableCount = 0; tableCount < tNoOfTables; tableCount++) {
  1167. MyOperations[tableCount] = 
  1168.   MyTransaction->getNdbOperation(tableName[tableCount]);
  1169. if (MyOperations[tableCount] == NULL) {
  1170.   tResult = 2;
  1171.   // Break for tableCount loop
  1172.   break;
  1173. } // if
  1175. check = MyOperations[tableCount]->readTuple();
  1176. if (check == -1) {
  1177.   tResult = 3;
  1178.   break;
  1179. } // if
  1181. check = MyOperations[tableCount]->
  1182.   equal((char*)attrName[0], (char*)&(pkValue[opCount]));
  1183. if (check == -1) {
  1184.   tResult = 7;
  1185.   break;
  1186. } // if
  1188. for (int attrCount = 0; attrCount < tNoOfAttributes - 1; attrCount++) {
  1189.   Index = tableCount * (tNoOfAttributes - 1) * tNoOfOperations * tAttributeSize +
  1190.     attrCount * tNoOfOperations * tAttributeSize + opCount * tAttributeSize;
  1191.   tmp = MyOperations[tableCount]->
  1192.     getValue((char*)attrName[attrCount + 1], (char*)&(readValue[Index]));
  1193.   
  1194.   if (tmp == NULL) {
  1195.     tResult = 9;
  1196.     break;
  1197. } // if
  1198. } // for attrCount
  1199.       } // for tableCount
  1200.       // Execute transaction reading one tuple in every table
  1201.       check = MyTransaction->execute(Commit);
  1202.       if (check == -1) {
  1203. ndbout << MyTransaction->getNdbError().message << endl;
  1205. // Add complete error handling here
  1207.               int retCode = flexScanErrorData->handleErrorCommon(MyTransaction->getNdbError());
  1208.               if (retCode == 1) {
  1209. if (MyTransaction->getNdbError().code != 626 && MyTransaction->getNdbError().code != 630){
  1210.                 ndbout_c("execute: %d, %s", opCount, MyTransaction ->getNdbError().message );
  1211.                 ndbout_c("Error code = %d", MyTransaction->getNdbError().code );}
  1212.                 tResult = 20;
  1213.               } else if (retCode == 2) {
  1214.                 ndbout << "4115 should not happen in flexBench" << endl;
  1215.                 tResult = 20;
  1216.               } else if (retCode == 3) {
  1217. // --------------------------------------------------------------------
  1218. // We are not certain if the transaction was successful or not.
  1219. // We must reexecute but might very well find that the transaction
  1220. // actually was updated. Updates and Reads are no problem here. Inserts
  1221. // will not cause a problem if error code 630 arrives. Deletes will
  1222. // not cause a problem if 626 arrives.
  1223. // --------------------------------------------------------------------
  1224. /* What can we do here? */
  1225.                 ndbout_c("execute: %s", MyTransaction ->getNdbError().message );
  1226.                  }//if(retCode == 3)
  1228.       } // if
  1229.       
  1230.       pNdb->closeTransaction(MyTransaction);
  1231.     } // else
  1232.   } // for opCount
  1234.   return(tResult);
  1235. } // readRows
  1237. static int scanReadRows(Ndb* pNdb, int* readValue)
  1238. {
  1239.   int tResult = 0;
  1240.   int tableCount = 0;
  1241.   int attrCount = 0;
  1242.   int check = 0;
  1243.   int countAbort = 0; // Counts loops until scan abort if requested
  1244.   NdbConnection* MyTransaction = NULL;
  1245.   NdbOperation* MyOperation = NULL;
  1246.   NdbRecAttr* tmp = NULL;
  1247.   
  1248.   
  1249.   for (tableCount = 0; tableCount < tNoOfTables; tableCount++) {
  1250.     MyTransaction = pNdb->startTransaction();
  1251.     if (MyTransaction == NULL) {
  1252.       tResult = 1;
  1253.       break;
  1254.     } // if
  1255.     MyOperation = MyTransaction->getNdbOperation(tableName[tableCount]);
  1256.     if (MyOperation == NULL) {
  1257.       tResult = 2;
  1258.       break;
  1259.     } // if
  1260.     
  1261.     check = MyOperation->openScanRead(tParallellism);
  1262.     if (check == -1) {
  1263.       tResult = 10;
  1264.       break;
  1265.     } // if
  1266.     
  1267.     for (int attrCount = 0; attrCount < tNoOfAttributes-1; attrCount++) {
  1268.       // Get all attributes
  1269.       tmp = MyOperation->
  1270. getValue((char*)attrName[attrCount+1],
  1271.  (char*)&(readValue[tableCount*(tNoOfAttributes-1)*tNoOfOperations*tAttributeSize +
  1272.    attrCount*tNoOfOperations*tAttributeSize]));
  1273.       if (tmp == NULL) {
  1274. tResult = 9;
  1275. break;
  1276.       } // if
  1277.     } // for attrCount
  1279.     check = MyTransaction->executeScan();
  1280.     if (check == -1) {
  1281.       tResult = 12;
  1282.       break;
  1283.     } // if
  1285.     check = MyTransaction->nextScanResult();
  1286.     while (check == 0) {
  1287.       // Check if scan abort is requested
  1288.       if (theScanAbortTestFlag == 1) {
  1289. if (countAbort == tAbortAfter) {
  1290.   MyTransaction->stopScan();
  1291.   ndbout << "scanread aborted on request after " << countAbort*tParallellism << 
  1292.     " tuples" << endl;
  1293.   break; // break while loop
  1294. } // if
  1295. countAbort++;
  1296.       } // if
  1297.       check = MyTransaction->nextScanResult();
  1298.     } // while
  1300.     pNdb->closeTransaction(MyTransaction);
  1301.   } // for tableCount
  1302.     
  1303.     return(tResult);
  1304. } // scanReadRows
  1306. static int scanUpdateRows(Ndb* pNdb, 
  1307.   int* readValue,
  1308.   int* attrValue)
  1309. {
  1310.   int tResult = 0;
  1311.   int tableCount = 0;
  1312.   int attrCount = 0;
  1313.   int check = 0;
  1314.   int opCount = 0;
  1315.   NdbConnection* MyTransaction = NULL;
  1316.   NdbOperation* MyOperation = NULL;
  1317.   NdbConnection* MyTakeOverTrans = NULL;
  1318.   NdbOperation* MyTakeOverOp = NULL;
  1319.   NdbRecAttr* tTmp = NULL;
  1321.   for (tableCount = 0; tableCount < tNoOfTables; tableCount++) {
  1322.     MyTransaction = pNdb->startTransaction();
  1323.     if (MyTransaction == NULL) {
  1324.       tResult = 1;
  1325.       break; // break tableCount for loop
  1326.     } // if
  1327.     MyOperation = MyTransaction->getNdbOperation(tableName[tableCount]);
  1328.     if (MyOperation == NULL) {
  1329.       tResult = 2;
  1330.       break;
  1331.     } // if
  1333.     check = MyOperation->openScanExclusive(tParallellism);
  1334.     if (check == -1) {
  1335.       tResult = 11;
  1336.       break;
  1337.     } // if
  1339.     MyOperation->interpret_exit_ok();
  1340.     // Fetch all attributes
  1341.     for (int attrCount = 0; attrCount < tNoOfAttributes-1; attrCount++) {
  1342.       tTmp = MyOperation->
  1343. getValue((char*)attrName[attrCount+1],
  1344.  (char*)&(readValue[tableCount*(tNoOfAttributes-1)*tNoOfOperations*tAttributeSize +
  1345.    attrCount*tNoOfOperations*tAttributeSize]));
  1346.       if (tTmp == NULL) {
  1347. tResult = 9;
  1348. break; // break for loop
  1349.       } // if
  1350.     } // for
  1351.     if (tResult != 0) {
  1352.       break; // break while loop also
  1353.     } // if
  1355.     check = MyTransaction->executeScan();
  1356.     if (check == -1) {
  1357.       tResult = 12;
  1358.       break;
  1359.     } // if
  1360.     check = MyTransaction->nextScanResult();
  1361.     opCount = 0;
  1362.     while (check == 0) {
  1363.       MyTakeOverTrans = pNdb->startTransaction();
  1364.       MyTakeOverOp = MyOperation->takeOverForUpdate(MyTakeOverTrans);
  1365.       for (attrCount = 0; attrCount < tNoOfAttributes-1; attrCount++) {
  1366. check = MyTakeOverOp->setValue((char*)attrName[attrCount+1],
  1367.        (char*)&(attrValue[tableCount*(tNoOfAttributes-1)*tNoOfOperations*tAttributeSize +
  1368.  attrCount*tNoOfOperations*tAttributeSize + opCount*tAttributeSize]));
  1369.       } // for
  1370.       
  1371.       check = MyTakeOverTrans->execute(Commit);
  1372.       if (check == 0) {
  1373. check = MyTransaction->nextScanResult();
  1374. opCount++;
  1375.       } // if
  1376.       else {
  1377. tResult = 95;
  1379. /* MyTransaction, MyTakeOverTrans, Which one? */
  1381. // Any further error handling?
  1382. int retCode = flexScanErrorData->handleErrorCommon(MyTakeOverTrans->getNdbError());
  1383. if (retCode == 1) {
  1384.   if (MyTakeOverTrans->getNdbError().code != 626 && MyTakeOverTrans->getNdbError().code != 630){
  1385.     ndbout_c("execute: %s", MyTakeOverTrans->getNdbError().message);
  1386.     ndbout_c("Error code = %d", MyTakeOverTrans->getNdbError().code);}
  1387.   tResult = 20;
  1388. } else if (retCode == 2) {
  1389.   ndbout << "4115 should not happen in flexBench" << endl;
  1390.   tResult = 20;
  1391. } else if (retCode == 3) {
  1392.   // --------------------------------------------------------------------
  1393.   // We are not certain if the transaction was successful or not.
  1394.   // We must reexecute but might very well find that the transaction
  1395.   // actually was updated. Updates and Reads are no problem here. Inserts
  1396.   // will not cause a problem if error code 630 arrives. Deletes will
  1397.   // not cause a problem if 626 arrives.
  1398.   // --------------------------------------------------------------------
  1399.   /* What can we do here? */
  1400.   ndbout_c("execute: %s", MyTakeOverTrans->getNdbError().message);
  1401. }//if(retCode == 3)
  1403.       } // else
  1404.       pNdb->closeTransaction(MyTakeOverTrans);
  1405.     } // while
  1406.     
  1407.     pNdb->closeTransaction(MyTransaction);
  1408.   } // for
  1410.   return(tResult);
  1411. } // scanUpdateRows
  1413. static int scanDeleteRows(Ndb* pNdb, int* readValue)
  1414. {
  1415.   int tResult = 0;
  1416.   int tableCount = 0;
  1417.   int attrCount = 0;
  1418.   int check = 0;
  1419.   NdbRecAttr* tTmp = NULL;
  1420.   NdbConnection* MyTransaction = NULL;
  1421.   NdbOperation* MyOperation = NULL;
  1422.   NdbConnection* MyTakeOverTrans = NULL;
  1423.   NdbOperation* MyTakeOverOp = NULL;
  1425.   for (tableCount = 0; tableCount < tNoOfTables; tableCount++) {
  1426.     MyTransaction = pNdb->startTransaction();
  1427.     if (MyTransaction == NULL) {
  1428.       tResult = 1;
  1429.       break; // break tableCount for loop
  1430.     } // if
  1432.     MyOperation = MyTransaction->getNdbOperation(tableName[tableCount]);
  1433.     if (MyOperation == NULL) {
  1434.       tResult = 2;
  1435.       break;
  1436.     } // if
  1438.     check = MyOperation->openScanExclusive(tParallellism);
  1439.     if (check == -1) {
  1440.       tResult = 11;
  1441.       break;
  1442.     } // if
  1444.     MyOperation->interpret_exit_ok();
  1445.     for (int attrCount = 0; attrCount < tNoOfAttributes-1; attrCount++) {
  1446.       tTmp = MyOperation->
  1447. getValue((char*)attrName[attrCount+1],
  1448.  (char*)&(readValue[tableCount*(tNoOfAttributes-1)*tNoOfOperations +
  1449.    attrCount*tNoOfOperations]));
  1450.       if (tTmp == NULL) {
  1451. tResult = 9;
  1452. break;
  1453.       } // if
  1454.     } // for
  1456.     check = MyTransaction->executeScan();
  1457.     if (check == -1) {
  1458.       tResult = 12;
  1459.       break;
  1460.     } // if
  1461.     check = MyTransaction->nextScanResult();
  1462.     while (check == 0) {
  1463.       MyTakeOverTrans = pNdb->startTransaction();
  1464.       MyTakeOverOp = MyOperation->takeOverForDelete(MyTakeOverTrans);
  1465.       check = MyTakeOverOp->deleteTuple();
  1467.       check = MyTakeOverTrans->execute(Commit);
  1469.       //Error handling here
  1471.               int retCode =flexScanErrorData->handleErrorCommon(MyTakeOverTrans->getNdbError());
  1472.               if (retCode == 1) {
  1473. if (MyTakeOverTrans->getNdbError().code != 626 && MyTakeOverTrans->getNdbError().code != 630){
  1474.                 ndbout_c("execute: %s", MyTakeOverTrans->getNdbError().message );
  1475.                 ndbout_c("Error code = %d", MyTakeOverTrans->getNdbError().code );}
  1476.                 tResult = 20;
  1477.               } else if (retCode == 2) {
  1478.                 ndbout << "4115 should not happen in flexBench" << endl;
  1479.                 tResult = 20;
  1480.               } else if (retCode == 3) {
  1481. // --------------------------------------------------------------------
  1482. // We are not certain if the transaction was successful or not.
  1483. // We must reexecute but might very well find that the transaction
  1484. // actually was updated. Updates and Reads are no problem here. Inserts
  1485. // will not cause a problem if error code 630 arrives. Deletes will
  1486. // not cause a problem if 626 arrives.
  1487. // --------------------------------------------------------------------
  1488. /* What can we do here? */
  1489.                 ndbout_c("execute: %s", MyTakeOverTrans->getNdbError().message );
  1490.                  }//if(retCode == 3) End of error handling
  1492.       pNdb->closeTransaction(MyTakeOverTrans);
  1493.       check = MyTransaction->nextScanResult();
  1494.     } // while
  1495.     pNdb->closeTransaction(MyTransaction);
  1496.   } // for tableCount
  1497.   return(tResult);
  1498. } // scanDeleteRows
  1500. static int deleteRows(Ndb* pNdb,
  1501.       int* pkValue)
  1502. {
  1503.   int tResult = 0;
  1504.   NdbConnection* MyTransaction = NULL;
  1505.   int tableCount = 0;
  1506.   int opCount = 0;
  1507.   int check = 0;
  1508.   NdbOperation* MyOperations[MAXTABLES] = {NULL};
  1510.   for (opCount = 0; opCount < tNoOfOperations; opCount++) {
  1511.     MyTransaction = pNdb->startTransaction();
  1512.     if (MyTransaction == NULL) {
  1513.       tResult = 1;
  1514.     } // if
  1515.     else {
  1516.       for (tableCount = 0; tableCount < tNoOfTables; tableCount++) {
  1518. MyOperations[tableCount] = 
  1519.   MyTransaction->getNdbOperation(tableName[tableCount]);
  1520. if (MyOperations[tableCount] == NULL) {
  1521.   tResult = 2;
  1522.   // Break for tableCount loop
  1523.   break;
  1524. } // if
  1526. check = MyOperations[tableCount]->deleteTuple();
  1527. if (check == -1) {
  1528.   tResult = 3;
  1529.   break;
  1530. } // if
  1532. check = MyOperations[tableCount]->
  1533.   equal((char*)attrName[0], (char*)&(pkValue[opCount]));
  1534. if (check == -1) {
  1535.   tResult = 7;
  1536.   break;
  1537. } // if
  1539.       } // for tableCount
  1540.       
  1541.       // Execute transaction deleting one tuple in every table
  1542.       check = MyTransaction->execute(Commit);
  1543.       if (check == -1) {
  1544. ndbout << MyTransaction->getNdbError().message << endl;
  1545. // Add complete error handling here
  1547.               int retCode = flexScanErrorData->handleErrorCommon(MyTransaction->getNdbError());
  1548.               if (retCode == 1) {
  1549. if (MyTransaction->getNdbError().code != 626 && MyTransaction->getNdbError().code != 630){
  1550.                 ndbout_c("execute: %d, %s", opCount, MyTransaction->getNdbError().message );
  1551.                 ndbout_c("Error code = %d", MyTransaction->getNdbError().code );}
  1552.                 tResult = 20;
  1553.               } else if (retCode == 2) {
  1554.                 ndbout << "4115 should not happen in flexBench" << endl;
  1555.                 tResult = 20;
  1556.               } else if (retCode == 3) {
  1557. // --------------------------------------------------------------------
  1558. // We are not certain if the transaction was successful or not.
  1559. // We must reexecute but might very well find that the transaction
  1560. // actually was updated. Updates and Reads are no problem here. Inserts
  1561. // will not cause a problem if error code 630 arrives. Deletes will
  1562. // not cause a problem if 626 arrives.
  1563. // --------------------------------------------------------------------
  1564. /* What can we do here? */
  1565.                 ndbout_c("execute: %s", MyTransaction->getNdbError().message );
  1566.                  }//if(retCode == 3)
  1568.       } // if
  1569.       
  1570.       pNdb->closeTransaction(MyTransaction);
  1571.     } // else
  1572.   } // for opCount
  1574.   return(tResult);
  1576. } // deleteRows
  1578. ////////////////////////////////////////
  1579. //
  1580. // Name: verifyDeleteRows
  1581. //
  1582. // Purpose: Verifies that all tables are empty by reading every tuple
  1583. //          No deletions made here
  1584. //
  1585. // Returns: 'Standard' error codes
  1586. //
  1587. /////////////////////////////////////
  1588. static int verifyDeleteRows(Ndb* pNdb,
  1589.     int* pkValue,
  1590.     int* readValue)
  1591. {
  1592.   int tResult = 0;
  1593.   int tableCount = 0;
  1594.   int attrCount = 0;
  1595.   int check = 0;
  1596.   NdbConnection* MyTransaction = NULL;
  1597.   NdbOperation* MyOperations = NULL;
  1598.   NdbRecAttr* tmp = NULL;
  1599.   int Value = 0;
  1600.   int Index = 0;
  1601.   int opCount = 0;
  1603.   for (opCount = 0; opCount < tNoOfOperations; opCount++) {
  1604.     for (tableCount = 0; tableCount < tNoOfTables; tableCount++) {
  1605.       MyTransaction = pNdb->startTransaction();
  1606.       if (MyTransaction == NULL) {
  1607. tResult = 1;
  1608.       } // if
  1609.       else {
  1611. MyOperations = 
  1612.   MyTransaction->getNdbOperation(tableName[tableCount]);
  1613. if (MyOperations == NULL) {
  1614.   tResult = 2;
  1615.   // Break for tableCount loop
  1616.   break;
  1617. } // if
  1619. check = MyOperations->readTuple();
  1620. if (check == -1) {
  1621.   tResult = 3;
  1622.   break;
  1623. } // if
  1625. check = MyOperations->
  1626.   equal((char*)attrName[0], (char*)&(pkValue[opCount]));
  1627. if (check == -1) {
  1628.   tResult = 7;
  1629.   break;
  1630. } // if
  1632. for (int attrCount = 0; attrCount < tNoOfAttributes - 1; attrCount++) {
  1633.   Index = tableCount * (tNoOfAttributes - 1) * tNoOfOperations * tAttributeSize +
  1634.     attrCount * tNoOfOperations * tAttributeSize + opCount * tAttributeSize;
  1635.   tmp = MyOperations->
  1636.     getValue((char*)attrName[attrCount + 1], (char*)&(readValue[Index]));
  1637.   
  1638.   if (tmp == NULL) {
  1639.     tResult = 9;
  1640.     break;
  1641.   } // if
  1642. } // for attrCount
  1643. // Execute transaction reading one tuple in every table
  1644. check = MyTransaction->execute(Commit);
  1645. if ((check == -1) && (MyTransaction->getNdbError().code == 626)){
  1646.   // This is expected because everything should be deleted 
  1647. } // if
  1648. else if (check == 0) {
  1649.   // We have found a tuple that should have been deleted
  1650.   ndbout << "tuple " << tableName[tableCount] << ":" <<
  1651.     opCount << " was never deleted" << endl;
  1652.   tResult = 97;
  1653. } // else if
  1654. else {
  1655.   // Unexpected error
  1656.   ndbout << "Unexpected error during delete" << endl;
  1657.   assert(false);
  1658. } // else
  1660. pNdb->closeTransaction(MyTransaction);
  1662.       } // else
  1663.     } // for tableCount
  1664.   } // for opCount
  1666.   return(tResult);
  1667. } // verifyDeleteRows