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

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

MySQL数据库

开发平台：

Visual C++

Bank.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 "Bank.hpp"
  18. #include <time.h>
  19. #include <NdbSleep.h>
  20. #include <UtilTransactions.hpp>
  22. Bank::Bank(bool _init):
  23.   m_ndb("BANK"),
  24.   m_maxAccount(-1),
  25.   m_initialized(false)
  26. {
  27.   if(_init)
  28.     init();
  29. }
  31. int Bank::init(){
  32.   if (m_initialized == true)
  33.     return NDBT_OK;
  35.   myRandom48Init(NdbTick_CurrentMillisecond());
  37.   m_ndb.init();   
  38.   if (m_ndb.waitUntilReady(30) != 0)
  39.   {
  40.     ndbout << "Ndb not ready" << endl;
  41.     return NDBT_FAILED;
  42.   }
  43.   
  44.   if (getNumAccounts() != NDBT_OK)
  45.     return NDBT_FAILED;
  47.   m_initialized = true;
  48.   return NDBT_OK;
  49. }
  51. int Bank::performTransactions(int maxSleepBetweenTrans, int yield){
  53.   int transactions = 0;
  55.   while(performTransaction() == NDBT_OK)
  56.   {
  57.     transactions++;
  58.     
  59.     if (maxSleepBetweenTrans > 0){
  60.       int val = myRandom48(maxSleepBetweenTrans);
  61.       NdbSleep_MilliSleep(val);      
  62.     }
  63.     
  64.     if((transactions % 100) == 0)
  65.       g_info << transactions  << endl;
  66.     
  67.     if (yield != 0 && transactions >= yield)
  68.       return NDBT_OK;
  69.   }
  71.   return NDBT_FAILED;
  73. }
  75. int Bank::performTransaction(){
  76.   int result = NDBT_OK;
  78.   if (m_maxAccount <= 0){
  79.     g_err << "No accounts in bank" << endl;
  80.     return NDBT_FAILED;
  81.   }
  83.   int fromAccount = myRandom48(m_maxAccount);
  84.   int toAccount = myRandom48(m_maxAccount);
  85.     
  86.   if (fromAccount == toAccount){
  87.     // Increase toAccount with 1
  88.     toAccount = (toAccount+1)%m_maxAccount;
  89.   }
  90.     
  91.   int maxAmount = getMaxAmount();
  92.     
  93.   int amount = myRandom48(maxAmount);
  95. retry_transaction:
  96.   int res = performTransaction(fromAccount, toAccount, amount);
  97.   if (res != 0){
  98.     switch (res){
  99.     case NDBT_FAILED:
  100.       g_err << "performTransaction returned NDBT_FAILED" << endl
  101.     << "  fromAccount = " << fromAccount << endl
  102.     << "  toAccount = " << toAccount << endl
  103.     << "  amount = " << amount << endl;
  104.       result = NDBT_FAILED;
  105.       break;
  106.     case NOT_ENOUGH_FUNDS:
  107.       //   ndbout << "performTransaction returned NOT_ENOUGH_FUNDS" << endl;
  108.       break;
  109.     case NDBT_TEMPORARY:
  110.       g_err << "TEMPORARY_ERRROR retrying" << endl;
  111.       goto retry_transaction;
  112.       break;
  113.     default:
  114.       g_info << "performTransaction returned "<<res << endl;
  115.       break;
  116.     }
  117.   }
  118.   return result;
  119. }
  121. /**
  122.  * Perform a transaction in the bank. 
  123.  * Ie. transfer money from one account to another.
  124.  *
  125.  * @param 
  126.  * @return 0 if successful or an error code
  127.  */
  128. int Bank::performTransaction(int fromAccountId,
  129.      int toAccountId,
  130.      int amount ){
  131.   /**
  132.    * 1. Start transaction
  133.    * 2. Check balance on from account, if there is
  134.    *    not enough funds abort transaction
  135.    * 3. Update ACCOUNT set balance = balance - amount on
  136.    *    from account 
  137.    * 4. Insert withdrawal in TRANSACTION
  138.    * 5. Insert deposit in transaction
  139.    * 6. Update ACCOUNT set balance = balance + amount on 
  140.    *    to account
  141.    * 7. Commit transaction
  142.    */ 
  143.   //  g_info << "performTransaction " << fromAccountId 
  144.   //  << ", "<<toAccountId<<", "<<amount << endl;
  146.   // Call the first implementation of this trans
  147.   // In the future we can have several different versions of this trans
  148.   // and call them randomly 
  149.   return performTransactionImpl1(fromAccountId, toAccountId, amount); 
  150. }
  153. int Bank::performTransactionImpl1(int fromAccountId,
  154.   int toAccountId,
  155.   int amount ){
  157.   int check;
  158.     
  159.   // Ok, all clear to do the transaction
  160.   Uint64 transId;
  161.   int result = NDBT_OK;
  162.   if ((result= getNextTransactionId(transId)) != NDBT_OK){
  163.     return result;
  164.   }
  166.   NdbConnection* pTrans = m_ndb.startTransaction();
  168.   if( pTrans == NULL ) {
  169.     const NdbError err = m_ndb.getNdbError();
  170.     if (err.status == NdbError::TemporaryError){
  171.       ERR(err);
  172.       return NDBT_TEMPORARY;
  173.     }
  174.     ERR(err);
  175.     return NDBT_FAILED;
  176.   }
  177.     
  178.   Uint64 currTime;
  179.   if (prepareGetCurrTimeOp(pTrans, currTime) != NDBT_OK){
  180.     ERR(pTrans->getNdbError());
  181.     m_ndb.closeTransaction(pTrans);
  182.     return NDBT_FAILED;
  183.   }
  185.   /** 
  186.    * Check balance on from account
  187.    */
  188.   NdbOperation* pOp = pTrans->getNdbOperation("ACCOUNT");
  189.   if (pOp == NULL) {
  190.     ERR(pTrans->getNdbError());
  191.     m_ndb.closeTransaction(pTrans);
  192.     return NDBT_FAILED;
  193.   }
  194.     
  195.   check = pOp->readTupleExclusive();
  196.   if( check == -1 ) {
  197.     ERR(pTrans->getNdbError());
  198.     m_ndb.closeTransaction(pTrans);
  199.     return NDBT_FAILED;
  200.   }
  201.     
  202.   check = pOp->equal("ACCOUNT_ID", fromAccountId);
  203.   if( check == -1 ) {
  204.     ERR(pTrans->getNdbError());
  205.     m_ndb.closeTransaction(pTrans);
  206.     return NDBT_FAILED;
  207.   }
  208.     
  209.   NdbRecAttr* balanceFromRec = pOp->getValue("BALANCE");
  210.   if( balanceFromRec ==NULL ) {
  211.     ERR(pTrans->getNdbError());
  212.     m_ndb.closeTransaction(pTrans);
  213.     return NDBT_FAILED;
  214.   }
  215.     
  216.   NdbRecAttr* fromAccountTypeRec = pOp->getValue("ACCOUNT_TYPE");
  217.   if( fromAccountTypeRec == NULL ) {
  218.     ERR(pTrans->getNdbError());
  219.     m_ndb.closeTransaction(pTrans);
  220.     return NDBT_FAILED;
  221.   }
  223.   /** 
  224.    * Read balance on to account
  225.    */
  226.   NdbOperation* pOp6 = pTrans->getNdbOperation("ACCOUNT");
  227.   if (pOp6 == NULL) {
  228.     ERR(pTrans->getNdbError());
  229.     m_ndb.closeTransaction(pTrans);
  230.     return NDBT_FAILED;
  231.   }
  232.     
  233.   check = pOp6->readTupleExclusive();
  234.   if( check == -1 ) {
  235.     ERR(pTrans->getNdbError());
  236.     m_ndb.closeTransaction(pTrans);
  237.     return NDBT_FAILED;
  238.   }
  239.     
  240.   check = pOp6->equal("ACCOUNT_ID", toAccountId);
  241.   if( check == -1 ) {
  242.     ERR(pTrans->getNdbError());
  243.     m_ndb.closeTransaction(pTrans);
  244.     return NDBT_FAILED;
  245.   }
  246.     
  247.   NdbRecAttr* balanceToRec = pOp6->getValue("BALANCE");
  248.   if( balanceToRec == NULL ) {
  249.     ERR(pTrans->getNdbError());
  250.     m_ndb.closeTransaction(pTrans);
  251.     return NDBT_FAILED;
  252.   }
  254.   NdbRecAttr* toAccountTypeRec = pOp6->getValue("ACCOUNT_TYPE");
  255.   if( toAccountTypeRec == NULL ) {
  256.     ERR(pTrans->getNdbError());
  257.     m_ndb.closeTransaction(pTrans);
  258.     return NDBT_FAILED;
  259.   }
  260.     
  261.   check = pTrans->execute(NoCommit);
  262.   if( check == -1 ) {
  263.     const NdbError err = pTrans->getNdbError();
  264.     m_ndb.closeTransaction(pTrans);    
  265.     if (err.status == NdbError::TemporaryError){
  266.       ERR(err);
  267.       return NDBT_TEMPORARY;
  268.     }
  269.     ERR(err);
  270.     return NDBT_FAILED;
  271.   }
  272.     
  274.   Uint32  balanceFrom = balanceFromRec->u_32_value();
  275.   //  ndbout << "balanceFrom: " << balanceFrom << endl;
  277.   if (((Int64)balanceFrom - amount) < 0){
  278.     m_ndb.closeTransaction(pTrans);      
  279.     //ndbout << "Not enough funds" << endl;      
  280.     return NOT_ENOUGH_FUNDS;
  281.   }
  283.   Uint32 fromAccountType = fromAccountTypeRec->u_32_value();
  285.   Uint32  balanceTo = balanceToRec->u_32_value();
  286.   //  ndbout << "balanceTo: " << balanceTo << endl;
  287.   Uint32 toAccountType = toAccountTypeRec->u_32_value();
  289.   /**
  290.    * Update balance on from account
  291.    */
  292.   NdbOperation* pOp2 = pTrans->getNdbOperation("ACCOUNT");
  293.   if (pOp2 == NULL) {
  294.     ERR(pTrans->getNdbError());
  295.     m_ndb.closeTransaction(pTrans);
  296.     return NDBT_FAILED;
  297.   }
  298.     
  299.   check = pOp2->updateTuple();
  300.   if( check == -1 ) {
  301.     ERR(pTrans->getNdbError());
  302.     m_ndb.closeTransaction(pTrans);
  303.     return NDBT_FAILED;
  304.   }
  305.     
  306.   check = pOp2->equal("ACCOUNT_ID", fromAccountId);
  307.   if( check == -1 ) {
  308.     ERR(pTrans->getNdbError());
  309.     m_ndb.closeTransaction(pTrans);
  310.     return NDBT_FAILED;
  311.   }
  313.   check = pOp2->setValue("BALANCE", balanceFrom - amount);
  314.   if( check == -1 ) {
  315.     ERR(pTrans->getNdbError());
  316.     m_ndb.closeTransaction(pTrans);
  317.     return NDBT_FAILED;
  318.   }
  320.   /**
  321.    * Update balance on to account
  322.    */
  323.   NdbOperation* pOp3 = pTrans->getNdbOperation("ACCOUNT");
  324.   if (pOp3 == NULL) {
  325.     ERR(pTrans->getNdbError());
  326.     m_ndb.closeTransaction(pTrans);
  327.     return NDBT_FAILED;
  328.   }
  329.     
  330.   check = pOp3->updateTuple();
  331.   if( check == -1 ) {
  332.     ERR(pTrans->getNdbError());
  333.     m_ndb.closeTransaction(pTrans);
  334.     return NDBT_FAILED;
  335.   }
  336.     
  337.   check = pOp3->equal("ACCOUNT_ID", toAccountId);
  338.   if( check == -1 ) {
  339.     ERR(pTrans->getNdbError());
  340.     m_ndb.closeTransaction(pTrans);
  341.     return NDBT_FAILED;
  342.   }
  344.   check = pOp3->setValue("BALANCE", balanceTo + amount);
  345.   if( check == -1 ) {
  346.     ERR(pTrans->getNdbError());
  347.     m_ndb.closeTransaction(pTrans);
  348.     return NDBT_FAILED;
  349.   }
  351.   /**
  352.    * Insert withdrawal transaction
  353.    */
  354.   NdbOperation* pOp4 = pTrans->getNdbOperation("TRANSACTION");
  355.   if (pOp4 == NULL) {
  356.     ERR(pTrans->getNdbError());
  357.     m_ndb.closeTransaction(pTrans);
  358.     return NDBT_FAILED;
  359.   }
  360.     
  361.   check = pOp4->insertTuple();
  362.   if( check == -1 ) {
  363.     ERR(pTrans->getNdbError());
  364.     m_ndb.closeTransaction(pTrans);
  365.     return NDBT_FAILED;
  366.   }
  367.     
  368.   check = pOp4->equal("TRANSACTION_ID", transId);
  369.   if( check == -1 ) {
  370.     ERR(pTrans->getNdbError());
  371.     m_ndb.closeTransaction(pTrans);
  372.     return NDBT_FAILED;
  373.   }
  375.   check = pOp4->equal("ACCOUNT", fromAccountId);
  376.   if( check == -1 ) {
  377.     ERR(pTrans->getNdbError());
  378.     m_ndb.closeTransaction(pTrans);
  379.     return NDBT_FAILED;
  380.   }
  382.   check = pOp4->setValue("ACCOUNT_TYPE", fromAccountType);
  383.   if( check == -1 ) {
  384.     ERR(pTrans->getNdbError());
  385.     m_ndb.closeTransaction(pTrans);
  386.     return NDBT_FAILED;
  387.   }
  389.   check = pOp4->setValue("OTHER_ACCOUNT", toAccountId);
  390.   if( check == -1 ) {
  391.     ERR(pTrans->getNdbError());
  392.     m_ndb.closeTransaction(pTrans);
  393.     return NDBT_FAILED;
  394.   }
  396.   check = pOp4->setValue("TRANSACTION_TYPE", WithDrawal);
  397.   if( check == -1 ) {
  398.     ERR(pTrans->getNdbError());
  399.     m_ndb.closeTransaction(pTrans);
  400.     return NDBT_FAILED;
  401.   }
  402.     
  403.   check = pOp4->setValue("TIME", currTime);
  404.   if( check == -1 ) {
  405.     ERR(pTrans->getNdbError());
  406.     m_ndb.closeTransaction(pTrans);
  407.     return NDBT_FAILED;
  408.   }
  410.   check = pOp4->setValue("AMOUNT", amount);
  411.   if( check == -1 ) {
  412.     ERR(pTrans->getNdbError());
  413.     m_ndb.closeTransaction(pTrans);
  414.     return NDBT_FAILED;
  415.   }
  417.   /**
  418.    * Insert deposit transaction
  419.    */
  420.   NdbOperation* pOp5 = pTrans->getNdbOperation("TRANSACTION");
  421.   if (pOp5 == NULL) {
  422.     ERR(pTrans->getNdbError());
  423.     m_ndb.closeTransaction(pTrans);
  424.     return NDBT_FAILED;
  425.   }
  426.     
  427.   check = pOp5->insertTuple();
  428.   if( check == -1 ) {
  429.     ERR(pTrans->getNdbError());
  430.     m_ndb.closeTransaction(pTrans);
  431.     return NDBT_FAILED;
  432.   }
  433.     
  434.   check = pOp5->equal("TRANSACTION_ID", transId);
  435.   if( check == -1 ) {
  436.     ERR(pTrans->getNdbError());
  437.     m_ndb.closeTransaction(pTrans);
  438.     return NDBT_FAILED;
  439.   }
  441.   check = pOp5->equal("ACCOUNT", toAccountId);
  442.   if( check == -1 ) {
  443.     ERR(pTrans->getNdbError());
  444.     m_ndb.closeTransaction(pTrans);
  445.     return NDBT_FAILED;
  446.   }
  448.   check = pOp5->setValue("ACCOUNT_TYPE", toAccountType);
  449.   if( check == -1 ) {
  450.     ERR(pTrans->getNdbError());
  451.     m_ndb.closeTransaction(pTrans);
  452.     return NDBT_FAILED;
  453.   }
  455.   check = pOp5->setValue("OTHER_ACCOUNT", fromAccountId);
  456.   if( check == -1 ) {
  457.     ERR(pTrans->getNdbError());
  458.     m_ndb.closeTransaction(pTrans);
  459.     return NDBT_FAILED;
  460.   }
  462.   check = pOp5->setValue("TRANSACTION_TYPE", Deposit);
  463.   if( check == -1 ) {
  464.     ERR(pTrans->getNdbError());
  465.     m_ndb.closeTransaction(pTrans);
  466.     return NDBT_FAILED;
  467.   }
  469.   check = pOp5->setValue("TIME", currTime);
  470.   if( check == -1 ) {
  471.     ERR(pTrans->getNdbError());
  472.     m_ndb.closeTransaction(pTrans);
  473.     return NDBT_FAILED;
  474.   }
  476.   check = pOp5->setValue("AMOUNT", amount);
  477.   if( check == -1 ) {
  478.     ERR(pTrans->getNdbError());
  479.     m_ndb.closeTransaction(pTrans);
  480.     return NDBT_FAILED;
  481.   }
  483.   check = pTrans->execute(Commit);
  484.   if( check == -1 ) {
  485.     const NdbError err = pTrans->getNdbError();
  486.     m_ndb.closeTransaction(pTrans);    
  487.     if (err.status == NdbError::TemporaryError){
  488.       ERR(err);
  489.       return NDBT_TEMPORARY;
  490.     }
  491.     ERR(err);
  492.     return NDBT_FAILED;
  493.   }
  494.     
  495.   m_ndb.closeTransaction(pTrans);      
  496.   return NDBT_OK;  
  497. }
  500.     
  502. int Bank::performMakeGLs(int yield){
  503.   int result;
  504.   
  505.   int counter, maxCounter;
  506.   int yieldCounter = 0;
  508.   while (1){
  509.     // Counters to keep tracck of how many
  510.     // GLs should be made before performing a validation
  511.     counter = 0;
  512.     maxCounter = 50 + myRandom48(100);
  513.     
  514.     /** 
  515.      * Validate GLs and Transactions for previous days
  516.      *
  517.      */
  518.     result = performValidateGLs();
  519.     if (result != NDBT_OK){
  520.       if (result == VERIFICATION_FAILED){
  521. g_err << "performValidateGLs verification failed" << endl;
  522. return NDBT_FAILED;
  523.       }
  524.       g_info << "performValidateGLs failed" << endl;
  525.       return NDBT_FAILED;
  526.       continue;
  527.     }
  529.     result = performValidatePurged();
  530.     if (result != NDBT_OK){
  531.       if (result == VERIFICATION_FAILED){
  532. g_err << "performValidatePurged verification failed" << endl;
  533. return NDBT_FAILED;
  534.       }
  535.       g_info << "performValidatePurged failed" << endl;
  536.       return NDBT_FAILED;
  537.     }
  539.     while (1){
  541.       yieldCounter++;
  542.       if (yield != 0 && yieldCounter >= yield)
  543. return NDBT_OK;
  545.       /**
  546.        * Find last GL time.  
  547.        * ( GL record with highest time value)
  548.        */
  549.       Uint64 lastGLTime;
  550.       if (findLastGL(lastGLTime) != NDBT_OK){
  551. g_info << "findLastGL failed" << endl;
  552. // Break out of inner while loop
  553. break;
  554.       }
  555.       
  556.       lastGLTime++;
  557.       
  558.       /** 
  559.        * If last GL time + 1 is smaller than current time
  560.        * perform a GL for that time
  561.        */
  562.       Uint64 currTime;
  563.       if (getCurrTime(currTime) != NDBT_OK){
  564. g_info << "getCurrTime failed" << endl;
  565. // Break out of inner while loop
  566. break;
  567.       }      
  568.       if (lastGLTime < currTime){
  569. counter++;
  570. if (performMakeGL(lastGLTime) != NDBT_OK){
  571.   g_info << "performMakeGL failed" << endl;
  572. // Break out of inner while loop
  573.   break;
  574. }
  576. if (counter > maxCounter){
  577.   // Break out of inner while loop and 
  578.   // validatePreviousGLs
  579.   g_info << "counter("<<counter<<") > maxCounter("<<maxCounter<<")" << endl;
  580.   break;
  581. }
  583.       } else {
  584. ;//ndbout << "It's not time to make GL yet" << endl;
  586. // ndbout << "Sleeping 1 second" << endl;
  587. NdbSleep_SecSleep(1);      
  589.       }
  590.       
  591.       Uint32 age = 3;
  592.       if (purgeOldGLTransactions(currTime, age) != NDBT_OK){
  593.         g_info << "purgeOldGLTransactions failed" << endl;
  594. // Break out of inner while loop
  595. break;
  596.       }     
  597.             
  598.     }
  599.   }
  600.     
  601.   return NDBT_FAILED;
  602.   
  603. }
  605. int Bank::performValidateAllGLs(){
  606.   int result;
  607.   
  608.   while (1){
  609.     
  610.     /** 
  611.      * Validate GLs and Transactions for previous days
  612.      * Set age so that ALL GL's are validated
  613.      */
  614.     int age = 100000;
  615.     result = performValidateGLs(age);
  616.     if (result != NDBT_OK){
  617.       if (result == VERIFICATION_FAILED){
  618. g_err << "performValidateGLs verification failed" << endl;
  619. return NDBT_FAILED;
  620.       }
  621.       g_err << "performValidateGLs failed" << endl;
  622.       return NDBT_FAILED;
  623.     }
  625.     /**
  626.      * 
  627.      *
  628.      */
  629.     result = performValidatePurged();
  630.     if (result != NDBT_OK){
  631.       if (result == VERIFICATION_FAILED){
  632. g_err << "performValidatePurged verification failed" << endl;
  633. return NDBT_FAILED;
  634.       }
  635.       g_err << "performValidatePurged failed" << endl;
  636.       return NDBT_FAILED;
  637.     }
  638.     return NDBT_OK;
  639.   }
  640.     
  641.   return NDBT_FAILED;
  642.   
  643. }
  645. int Bank::findLastGL(Uint64 &lastTime){
  647.  int check;  
  648.   /**
  649.    * SELECT MAX(time) FROM GL
  650.    */
  651.   NdbConnection* pScanTrans = m_ndb.startTransaction();
  652.   if (pScanTrans == NULL) {
  653.     ERR(m_ndb.getNdbError());
  654.     return NDBT_FAILED;
  655.   }
  656.       
  657.   NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("GL");
  658.   if (pOp == NULL) {
  659.     ERR(pScanTrans->getNdbError());
  660.     m_ndb.closeTransaction(pScanTrans);
  661.     return NDBT_FAILED;
  662.   }
  664.   NdbResultSet * rs = pOp->readTuples();
  665.   if( rs == 0 ) {
  666.     ERR(pScanTrans->getNdbError());
  667.     m_ndb.closeTransaction(pScanTrans);
  668.     return NDBT_FAILED;
  669.   }
  671.   check = pOp->interpret_exit_ok();
  672.   if( check == -1 ) {
  673.     ERR(pScanTrans->getNdbError());
  674.     m_ndb.closeTransaction(pScanTrans);
  675.     return NDBT_FAILED;
  676.   }
  678.   NdbRecAttr* timeRec = pOp->getValue("TIME");
  679.   if( timeRec ==NULL ) {
  680.     ERR(pScanTrans->getNdbError());
  681.     m_ndb.closeTransaction(pScanTrans);
  682.     return NDBT_FAILED;
  683.   }
  685.   check = pScanTrans->execute(NoCommit);
  686.   if( check == -1 ) {
  687.     ERR(pScanTrans->getNdbError());
  688.     m_ndb.closeTransaction(pScanTrans);
  689.     return NDBT_FAILED;
  690.   }
  691.     
  692.   int eof;
  693.   int rows = 0;
  694.   eof = rs->nextResult();
  695.   lastTime = 0;
  696.     
  697.   while(eof == 0){
  698.     rows++;
  699.     Uint64 t = timeRec->u_32_value();
  701.     if (t > lastTime)
  702.       lastTime = t;
  703.     
  704.     eof = rs->nextResult();
  705.   }
  706.   if (eof == -1) {
  707.     ERR(pScanTrans->getNdbError());
  708.     m_ndb.closeTransaction(pScanTrans);
  709.     return NDBT_FAILED;
  710.   }
  711.     
  712.   m_ndb.closeTransaction(pScanTrans);
  713.   
  714.   return NDBT_OK;
  715. }
  718. int Bank::performMakeGL(int time){
  719.   g_info << "performMakeGL: " << time << endl;
  720.   /**
  721.    *  Create one GL record for each account type.
  722.    *  All in the same transaction
  723.    */
  724.   // Start transaction    
  725.   NdbConnection* pTrans = m_ndb.startTransaction();
  726.   if (pTrans == NULL){
  727.     ERR(m_ndb.getNdbError());
  728.     return NDBT_FAILED;
  729.   }
  730.   for (int i = 0; i < getNumAccountTypes(); i++){
  731.   
  732.     if (performMakeGLForAccountType(pTrans, time, i) != NDBT_OK){
  733.       g_err << "performMakeGLForAccountType returned NDBT_FAILED"<<endl;
  734.       m_ndb.closeTransaction(pTrans);      
  735.       return NDBT_FAILED;
  736.     }
  737.   }
  738.   // Execute transaction    
  739.   if( pTrans->execute(Commit) == -1 ) {
  740.     ERR(pTrans->getNdbError());
  741.     m_ndb.closeTransaction(pTrans);
  742.     return NDBT_FAILED;
  743.   }    
  744.   m_ndb.closeTransaction(pTrans);      
  745.   
  746.   return NDBT_OK;
  747. }
  749. int Bank::performMakeGLForAccountType(NdbConnection* pTrans, 
  750.       Uint64 glTime,
  751.       Uint32 accountTypeId){
  752.   int check;
  754.   Uint32 balance = 0;
  755.   Uint32 withdrawalCount = 0;
  756.   Uint32 withdrawalSum = 0;
  757.   Uint32 depositSum = 0;
  758.   Uint32 depositCount = 0;
  759.   Uint32 countTransactions = 0;
  760.   Uint32 purged = 0;
  762.   // Insert record in GL so that we know
  763.   // that no one else is performing the same task
  764.   // Set purged = 0 to indicate that TRANSACTION
  765.   // records still exist
  766.   NdbOperation* pOp = pTrans->getNdbOperation("GL");
  767.   if (pOp == NULL) {
  768.     ERR(pTrans->getNdbError());
  769.     return NDBT_FAILED;
  770.   }
  771.     
  772.   check = pOp->insertTuple();
  773.   if( check == -1 ) {
  774.     ERR(pTrans->getNdbError());
  775.     return NDBT_FAILED;
  776.   }
  777.       
  778.   check = pOp->equal("TIME", glTime);
  779.   if( check == -1 ) {
  780.     ERR(pTrans->getNdbError());
  781.     return NDBT_FAILED;
  782.   }
  784.   check = pOp->equal("ACCOUNT_TYPE", accountTypeId);
  785.   if( check == -1 ) {
  786.     ERR(pTrans->getNdbError());
  787.     return NDBT_FAILED;
  788.   }
  790.   check = pOp->setValue("BALANCE", balance);
  791.   if( check == -1 ) {
  792.     ERR(pTrans->getNdbError());
  793.     return NDBT_FAILED;
  794.   }
  796.   check = pOp->setValue("DEPOSIT_COUNT", depositCount);
  797.   if( check == -1 ) {
  798.     ERR(pTrans->getNdbError());
  799.     return NDBT_FAILED;
  800.   }
  802.   check = pOp->setValue("DEPOSIT_SUM", depositSum);
  803.   if( check == -1 ) {
  804.     ERR(pTrans->getNdbError());
  805.     return NDBT_FAILED;
  806.   }
  808.   check = pOp->setValue("WITHDRAWAL_COUNT", withdrawalCount);
  809.   if( check == -1 ) {
  810.     ERR(pTrans->getNdbError());
  811.     return NDBT_FAILED;
  812.   }
  814.   check = pOp->setValue("WITHDRAWAL_SUM", withdrawalSum);
  815.   if( check == -1 ) {
  816.     ERR(pTrans->getNdbError());
  817.     return NDBT_FAILED;
  818.   }
  820.   check = pOp->setValue("PURGED", purged);
  821.   if( check == -1 ) {
  822.     ERR(pTrans->getNdbError());
  823.     return NDBT_FAILED;
  824.   }
  825.       
  826.   check = pTrans->execute(NoCommit);
  827.   if( check == -1 ) {
  828.     ERR(pOp->getNdbError());
  829.     return NDBT_FAILED;
  830.   }
  832.   // Read previous GL record to get old balance
  833.   NdbOperation* pOp2 = pTrans->getNdbOperation("GL");
  834.   if (pOp2 == NULL) {
  835.     ERR(pTrans->getNdbError());
  836.     return NDBT_FAILED;
  837.   }
  838.     
  839.   check = pOp2->readTuple();
  840.   if( check == -1 ) {
  841.     ERR(pTrans->getNdbError());
  842.     return NDBT_FAILED;
  843.   }
  844.       
  845.   check = pOp2->equal("TIME", glTime-1);
  846.   if( check == -1 ) {
  847.     ERR(pTrans->getNdbError());
  848.     return NDBT_FAILED;
  849.   }
  851.   check = pOp2->equal("ACCOUNT_TYPE", accountTypeId);
  852.   if( check == -1 ) {
  853.     ERR(pTrans->getNdbError());
  854.     return NDBT_FAILED;
  855.   }
  857.   NdbRecAttr* oldBalanceRec = pOp2->getValue("BALANCE");
  858.   if( oldBalanceRec == NULL ) {
  859.     ERR(pTrans->getNdbError());
  860.     return NDBT_FAILED;
  861.   }
  863.   check = pTrans->execute(NoCommit);
  864.   if( check == -1 ) {
  865.     ERR(pOp2->getNdbError());
  866.     return NDBT_FAILED;
  867.   }    
  869.   Uint32 oldBalance = oldBalanceRec->u_32_value();
  870.   //  ndbout << "oldBalance = "<<oldBalance<<endl;
  871.   balance = oldBalance;
  872.   // Start a scan transaction to search
  873.   // for TRANSACTION records with TIME = time 
  874.   // and ACCOUNT_TYPE = accountTypeId
  875.   // Build sum of all found transactions
  876.     
  877.   if (sumTransactionsForGL(glTime, 
  878.    accountTypeId,
  879.    balance,
  880.    withdrawalCount,
  881.    withdrawalSum,
  882.    depositSum,
  883.    depositCount,
  884.    countTransactions,
  885.    pTrans) != NDBT_OK){
  886.     return NDBT_FAILED;
  887.   }
  888.   //  ndbout << "sumTransactionsForGL completed" << endl;
  889.   //  ndbout << "balance="<<balance<<endl
  890.   //  << "withdrawalCount="<<withdrawalCount<<endl
  891.   //  << "withdrawalSum="<<withdrawalSum<<endl
  892.   //  << "depositCount="<<depositCount<<endl
  893.   //  << "depositSum="<<depositSum<<endl;
  894.       
  897.   NdbOperation* pOp3 = pTrans->getNdbOperation("GL");
  898.   if (pOp3 == NULL) {
  899.     ERR(pTrans->getNdbError());
  900.     return NDBT_FAILED;
  901.   }
  902.     
  903.   check = pOp3->updateTuple();
  904.   if( check == -1 ) {
  905.     ERR(pTrans->getNdbError());
  906.     return NDBT_FAILED;
  907.   }
  908.       
  909.   check = pOp3->equal("TIME", glTime);
  910.   if( check == -1 ) {
  911.     ERR(pTrans->getNdbError());
  912.     return NDBT_FAILED;
  913.   }
  915.   check = pOp3->equal("ACCOUNT_TYPE", accountTypeId);
  916.   if( check == -1 ) {
  917.     ERR(pTrans->getNdbError());
  918.     return NDBT_FAILED;
  919.   }
  921.   check = pOp3->setValue("BALANCE", balance);
  922.   if( check == -1 ) {
  923.     ERR(pTrans->getNdbError());
  924.     return NDBT_FAILED;
  925.   }
  927.   check = pOp3->setValue("DEPOSIT_COUNT", depositCount);
  928.   if( check == -1 ) {
  929.     ERR(pTrans->getNdbError());
  930.     return NDBT_FAILED;
  931.   }
  933.   check = pOp3->setValue("DEPOSIT_SUM", depositSum);
  934.   if( check == -1 ) {
  935.     ERR(pTrans->getNdbError());
  936.     return NDBT_FAILED;
  937.   }
  939.   check = pOp3->setValue("WITHDRAWAL_COUNT", withdrawalCount);
  940.   if( check == -1 ) {
  941.     ERR(pTrans->getNdbError());
  942.     return NDBT_FAILED;
  943.   }
  945.   check = pOp3->setValue("WITHDRAWAL_SUM", withdrawalSum);
  946.   if( check == -1 ) {
  947.     ERR(pTrans->getNdbError());
  948.     return NDBT_FAILED;
  949.   }
  951.   check = pOp3->setValue("PURGED", purged);
  952.   if( check == -1 ) {
  953.     ERR(pTrans->getNdbError());
  954.     return NDBT_FAILED;
  955.   }
  957.   // Execute transaction    
  958.   check = pTrans->execute(NoCommit);
  959.   if( check == -1 ) {
  960.     ERR(pTrans->getNdbError());
  961.     return NDBT_FAILED;
  962.   }    
  964.   return NDBT_OK;
  965. }
  970. int Bank::sumTransactionsForGL(const Uint64 glTime, 
  971.        const Uint32 accountType,
  972.        Uint32& balance,
  973.        Uint32& withdrawalCount,
  974.        Uint32& withdrawalSum,
  975.        Uint32& depositSum,
  976.        Uint32& depositCount,
  977.        Uint32& transactionsCount,
  978.        NdbConnection* pTrans){
  979.   int check;
  981.   //  g_info << "sumTransactionsForGL: " << glTime << ", " << accountType << endl;
  982.     
  983.   NdbConnection* pScanTrans = m_ndb.startTransaction();
  984.   if (pScanTrans == NULL) {
  985.     ERR(m_ndb.getNdbError());
  986.     return NDBT_FAILED;
  987.   }
  988.       
  989.   NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("TRANSACTION");
  990.   if (pOp == NULL) {
  991.     ERR(pScanTrans->getNdbError());
  992.     m_ndb.closeTransaction(pScanTrans);
  993.     return NDBT_FAILED;
  994.   }
  996.   NdbResultSet * rs = pOp->readTuplesExclusive();
  997.   if( rs == 0 ) {
  998.     ERR(pScanTrans->getNdbError());
  999.     m_ndb.closeTransaction(pScanTrans);
  1000.     return NDBT_FAILED;
  1001.   }
  1003.   check = pOp->interpret_exit_ok();
  1004.   if( check == -1 ) {
  1005.     ERR(pScanTrans->getNdbError());
  1006.     m_ndb.closeTransaction(pScanTrans);
  1007.     return NDBT_FAILED;
  1008.   }
  1010.   NdbRecAttr* accountTypeRec = pOp->getValue("ACCOUNT_TYPE");
  1011.   if( accountTypeRec ==NULL ) {
  1012.     ERR(pScanTrans->getNdbError());
  1013.     m_ndb.closeTransaction(pScanTrans);
  1014.     return NDBT_FAILED;
  1015.   }
  1017.   NdbRecAttr* timeRec = pOp->getValue("TIME");
  1018.   if( timeRec ==NULL ) {
  1019.     ERR(pScanTrans->getNdbError());
  1020.     m_ndb.closeTransaction(pScanTrans);
  1021.     return NDBT_FAILED;
  1022.   }
  1024.   NdbRecAttr* transTypeRec = pOp->getValue("TRANSACTION_TYPE");
  1025.   if( transTypeRec ==NULL ) {
  1026.     ERR(pScanTrans->getNdbError());
  1027.     m_ndb.closeTransaction(pScanTrans);
  1028.     return NDBT_FAILED;
  1029.   }
  1031.   NdbRecAttr* amountRec = pOp->getValue("AMOUNT");
  1032.   if( amountRec ==NULL ) {
  1033.     ERR(pScanTrans->getNdbError());
  1034.     m_ndb.closeTransaction(pScanTrans);
  1035.     return NDBT_FAILED;
  1036.   }
  1038.   check = pScanTrans->execute(NoCommit);
  1039.   if( check == -1 ) {
  1040.     ERR(pScanTrans->getNdbError());
  1041.     m_ndb.closeTransaction(pScanTrans);
  1042.     return NDBT_FAILED;
  1043.   }
  1044.     
  1045.   int eof;
  1046.   int rows = 0;
  1047.   int rowsFound = 0;
  1048.   eof = rs->nextResult();
  1049.     
  1050.   while(eof == 0){
  1051.     rows++;
  1052.     Uint32 a = accountTypeRec->u_32_value();
  1053.     Uint64 t = timeRec->u_64_value();
  1055.     if (a == accountType && t == glTime){
  1056.       rowsFound++;
  1057.       // One record found
  1058.       int transType = transTypeRec->u_32_value();
  1059.       int amount = amountRec->u_32_value();
  1060.       if (transType == WithDrawal){
  1061. withdrawalCount++;
  1062. withdrawalSum += amount;
  1063. balance -= amount;
  1064.       } else {   
  1065. assert(transType == Deposit);
  1066. depositCount++;
  1067. depositSum += amount;
  1068. balance += amount;
  1069.       }
  1070.     }
  1072.     eof = rs->nextResult();
  1074.     if ((rows % 100) == 0){
  1075.       // "refresh" ownner transaction every 100th row
  1076.       if (pTrans->refresh() == -1) {
  1077. ERR(pTrans->getNdbError());
  1078. return NDBT_FAILED;
  1079.       }
  1080.     }
  1082.   }
  1083.   if (eof == -1) {
  1084.     ERR(pScanTrans->getNdbError());
  1085.     m_ndb.closeTransaction(pScanTrans);
  1086.     return NDBT_FAILED;
  1087.   }
  1088.     
  1089.   m_ndb.closeTransaction(pScanTrans);
  1090.   //  ndbout << rows << " TRANSACTIONS have been read" << endl;
  1091.   transactionsCount = rowsFound;
  1093.   return NDBT_OK;
  1095. }
  1097.  int Bank::performValidateGLs(Uint64 age){
  1099.   Uint64 currTime;
  1100.   if (getCurrTime(currTime) != NDBT_OK){
  1101.     return NDBT_FAILED;
  1102.   }
  1103.   Uint64 glTime = currTime - 1;
  1104.   while((glTime > 0) && ((glTime + age) >= currTime)){
  1105.     
  1106.     int result = performValidateGL(glTime);
  1107.     if (result != NDBT_OK){
  1108.       g_err << "performValidateGL failed" << endl;
  1109.       return result;
  1110.     }
  1111.     
  1112.     glTime--;
  1113.   }
  1114.   
  1115.   return NDBT_OK;
  1116.  }
  1118. int Bank::performValidateGL(Uint64 glTime){
  1119.    
  1120.    ndbout << "performValidateGL: " << glTime << endl;
  1121.    /**
  1122.     * Rules: 
  1123.     * - There should be zero or NoAccountTypes GL records for each glTime
  1124.     * - If purged == 0, then the TRANSACTION table should be checked
  1125.     *   to see that there are:
  1126.     *   + DEPOSIT_COUNT deposit transactions with account_type == ACCOUNT_TYPE
  1127.     *     and TIME == glTime. The sum of these transactions should be 
  1128.     *     DEPOSIT_SUM
  1129.     *   + WITHDRAWAL_COUNT withdrawal transactions with account_type == 
  1130.     *     ACCOUNT_TYPE and TIME == glTime. The sum of these transactions 
  1131.     *     should be WITHDRAWAL_SUM
  1132.     *   + BALANCE should be equal to the sum of all transactions plus
  1133.     *     the balance of the previous GL record
  1134.     * - If purged == 1 then there should be NO transactions with TIME == glTime
  1135.     *   and ACCOUNT_TYPE == account_type
  1136.     *  
  1137.     */ 
  1139.    int check;  
  1140.    /**
  1141.     * SELECT * FROM GL WHERE account_type = @accountType and time = @time
  1142.     */
  1143.    NdbConnection* pScanTrans = m_ndb.startTransaction();
  1144.    if (pScanTrans == NULL) {
  1145.      ERR(m_ndb.getNdbError());
  1146.      return NDBT_FAILED;
  1147.    }
  1148.    
  1149.    NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("GL");
  1150.    if (pOp == NULL) {
  1151.      ERR(pScanTrans->getNdbError());
  1152.      m_ndb.closeTransaction(pScanTrans);
  1153.      return NDBT_FAILED;
  1154.    }
  1155.    
  1156.    NdbResultSet * rs = pOp->readTuples();
  1157.    if( rs == 0 ) {
  1158.      ERR(pScanTrans->getNdbError());
  1159.      m_ndb.closeTransaction(pScanTrans);
  1160.      return NDBT_FAILED;
  1161.    }
  1162.    
  1163.    check = pOp->interpret_exit_ok();
  1164.    if( check == -1 ) {
  1165.      ERR(pScanTrans->getNdbError());
  1166.      m_ndb.closeTransaction(pScanTrans);
  1167.      return NDBT_FAILED;
  1168.    }
  1169.    
  1170.    NdbRecAttr* accountTypeRec = pOp->getValue("ACCOUNT_TYPE");
  1171.    if( accountTypeRec ==NULL ) {
  1172.      ERR(pScanTrans->getNdbError());
  1173.      m_ndb.closeTransaction(pScanTrans);
  1174.      return NDBT_FAILED;
  1175.    }
  1177.   NdbRecAttr* timeRec = pOp->getValue("TIME");
  1178.   if( timeRec ==NULL ) {
  1179.     ERR(pScanTrans->getNdbError());
  1180.     m_ndb.closeTransaction(pScanTrans);
  1181.     return NDBT_FAILED;
  1182.   }
  1184.   NdbRecAttr* purgedRec = pOp->getValue("PURGED");
  1185.   if( purgedRec ==NULL ) {
  1186.     ERR(pScanTrans->getNdbError());
  1187.     m_ndb.closeTransaction(pScanTrans);
  1188.     return NDBT_FAILED;
  1189.   }
  1191.   NdbRecAttr* balanceRec = pOp->getValue("BALANCE");
  1192.   if( balanceRec ==NULL ) {
  1193.     ERR(pScanTrans->getNdbError());
  1194.     m_ndb.closeTransaction(pScanTrans);
  1195.     return NDBT_FAILED;
  1196.   }
  1198.   NdbRecAttr* depositSumRec = pOp->getValue("DEPOSIT_SUM");
  1199.   if( depositSumRec ==NULL ) {
  1200.     ERR(pScanTrans->getNdbError());
  1201.     m_ndb.closeTransaction(pScanTrans);
  1202.     return NDBT_FAILED;
  1203.   }
  1205.   NdbRecAttr* depositCountRec = pOp->getValue("DEPOSIT_COUNT");
  1206.   if( depositCountRec ==NULL ) {
  1207.     ERR(pScanTrans->getNdbError());
  1208.     m_ndb.closeTransaction(pScanTrans);
  1209.     return NDBT_FAILED;
  1210.   }
  1212.   NdbRecAttr* withdrawalSumRec = pOp->getValue("WITHDRAWAL_SUM");
  1213.   if( withdrawalSumRec ==NULL ) {
  1214.     ERR(pScanTrans->getNdbError());
  1215.     m_ndb.closeTransaction(pScanTrans);
  1216.     return NDBT_FAILED;
  1217.   }
  1218.   NdbRecAttr* withdrawalCountRec = pOp->getValue("WITHDRAWAL_COUNT");
  1219.   if( withdrawalCountRec ==NULL ) {
  1220.     ERR(pScanTrans->getNdbError());
  1221.     m_ndb.closeTransaction(pScanTrans);
  1222.     return NDBT_FAILED;
  1223.   }
  1225.   check = pScanTrans->execute(NoCommit);
  1226.   if( check == -1 ) {
  1227.     ERR(pScanTrans->getNdbError());
  1228.     m_ndb.closeTransaction(pScanTrans);
  1229.     return NDBT_FAILED;
  1230.   }
  1232.   int eof;
  1233.   int rows = 0;
  1234.   int countGlRecords = 0;
  1235.   int result = NDBT_OK;
  1236.   eof = rs->nextResult();
  1237.     
  1238.   while(eof == 0){
  1239.     rows++;
  1240.     Uint64 t = timeRec->u_64_value();
  1242.     if (t == glTime){
  1243.       countGlRecords++;
  1244.       Uint32 a = accountTypeRec->u_32_value();
  1245.       Uint32 purged = purgedRec->u_32_value();
  1246.       Uint32 wsum = withdrawalSumRec->u_32_value();
  1247.       Uint32 wcount = withdrawalCountRec->u_32_value();
  1248.       Uint32 dsum = depositSumRec->u_32_value();
  1249.       Uint32 dcount = depositCountRec->u_32_value();
  1250.       Uint32 b = balanceRec->u_32_value();
  1252.       Uint32 balance = 0; 
  1253.       Uint32 withdrawalSum = 0;
  1254.       Uint32 withdrawalCount = 0;
  1255.       Uint32 depositSum = 0;
  1256.       Uint32 depositCount = 0;
  1257.       Uint32 countTransactions = 0;
  1258.       if (purged == 0){
  1259. // If purged == 0, then the TRANSACTION table should be checked
  1260. // to see that there are:
  1261. // + DEPOSIT_COUNT deposit transactions with account_type == ACCOUNT_TYPE
  1262. //   and TIME == glTime. The sum of these transactions should be 
  1263. //   DEPOSIT_SUM
  1264. // + WITHDRAWAL_COUNT withdrawal transactions with account_type == 
  1265. //   ACCOUNT_TYPE and TIME == glTime. The sum of these transactions 
  1266. //   should be WITHDRAWAL_SUM
  1267. // + BALANCE should be equal to the sum of all transactions plus
  1268. //   the balance of the previous GL record
  1269. if (sumTransactionsForGL(t, 
  1270.  a,
  1271.  balance,
  1272.  withdrawalCount,
  1273.  withdrawalSum,
  1274.  depositSum,
  1275.  depositCount,
  1276.  countTransactions,
  1277.  pScanTrans) != NDBT_OK){
  1278.   result = NDBT_FAILED;   
  1279. } else {
  1280.   Uint32 prevBalance = 0;
  1281.   if (getBalanceForGL(t-1, a, prevBalance) != NDBT_OK){
  1282.     result = NDBT_FAILED;
  1283.   } else
  1284.   if (((prevBalance + balance) != b) ||
  1285.       (wsum != withdrawalSum) ||
  1286.       (wcount != withdrawalCount) ||
  1287.       (dsum != depositSum) ||
  1288.       (dcount != depositCount)){
  1289.     g_err << "performValidateGL, sums and counts failed" << endl
  1290.   << "balance   :   " << balance+prevBalance << "!="<<b<<endl
  1291.   << "with sum  :   " << withdrawalSum << "!="<<wsum<<endl
  1292.   << "with count:   " << withdrawalCount << "!="<<wcount<<endl
  1293.   << "dep sum   :   " << depositSum << "!="<<dsum<<endl
  1294.   << "dep count :   " << depositCount << "!="<<dcount<<endl;
  1295.     result = VERIFICATION_FAILED;
  1296.   }
  1297.     }   
  1299.       } else {
  1300. assert(purged == 1);
  1301. // If purged == 1 then there should be NO transactions with 
  1302. // TIME == glTime and ACCOUNT_TYPE == account_type
  1304. if (sumTransactionsForGL(t, 
  1305.  a,
  1306.  balance,
  1307.  withdrawalCount,
  1308.  withdrawalSum,
  1309.  depositSum,
  1310.  depositCount,
  1311.  countTransactions,
  1312.  pScanTrans) != NDBT_OK){
  1313.   result = NDBT_FAILED;   
  1314. } else {
  1315.   if (countTransactions != 0){
  1316.     g_err << "performValidateGL, countTransactions("<<countTransactions<<") != 0" << endl;
  1317.     result = VERIFICATION_FAILED;
  1318.   }
  1319. }  
  1320.       }
  1322.     }
  1323.     eof = rs->nextResult();
  1324.   }
  1325.   if (eof == -1) {
  1326.     ERR(pScanTrans->getNdbError());
  1327.     m_ndb.closeTransaction(pScanTrans);
  1328.     return NDBT_FAILED;
  1329.   }
  1330.     
  1331.   m_ndb.closeTransaction(pScanTrans);
  1333.   // - There should be zero or NoAccountTypes GL records for each glTime
  1334.   if ((countGlRecords != 0) && (countGlRecords != getNumAccountTypes())){
  1335.     g_err << "performValidateGL: " << endl
  1336.    << "countGlRecords = " << countGlRecords << endl;
  1337.     result = VERIFICATION_FAILED;
  1338.   }
  1340.   return result;
  1342.    
  1343.  }
  1345. int Bank::getBalanceForGL(const Uint64 glTime,
  1346.   const Uint32 accountTypeId,
  1347.   Uint32 &balance){
  1348.   int check;
  1350.   NdbConnection* pTrans = m_ndb.startTransaction();
  1351.   if (pTrans == NULL) {
  1352.     ERR(m_ndb.getNdbError());
  1353.     return NDBT_FAILED;
  1354.   }
  1355.   
  1356.   NdbOperation* pOp = pTrans->getNdbOperation("GL");
  1357.   if (pOp == NULL) {
  1358.     ERR(pTrans->getNdbError());
  1359.     return NDBT_FAILED;
  1360.   }
  1361.     
  1362.   check = pOp->readTuple();
  1363.   if( check == -1 ) {
  1364.     ERR(pTrans->getNdbError());
  1365.     return NDBT_FAILED;
  1366.   }
  1367.       
  1368.   check = pOp->equal("TIME", glTime);
  1369.   if( check == -1 ) {
  1370.     ERR(pTrans->getNdbError());
  1371.     return NDBT_FAILED;
  1372.   }
  1374.   check = pOp->equal("ACCOUNT_TYPE", accountTypeId);
  1375.   if( check == -1 ) {
  1376.     ERR(pTrans->getNdbError());
  1377.     return NDBT_FAILED;
  1378.   }
  1380.   NdbRecAttr* balanceRec = pOp->getValue("BALANCE");
  1381.   if( balanceRec == NULL ) {
  1382.     ERR(pTrans->getNdbError());
  1383.     return NDBT_FAILED;
  1384.   }
  1386.   check = pTrans->execute(Commit);
  1387.   if( check == -1 ) {
  1388.     ERR(pTrans->getNdbError());
  1389.     return NDBT_FAILED;
  1390.   } 
  1392.   m_ndb.closeTransaction(pTrans);
  1394.   balance = balanceRec->u_32_value();
  1396.   return NDBT_OK;
  1397. }
  1401. int Bank::getOldestPurgedGL(const Uint32 accountType,
  1402.     Uint64 &oldest){
  1403.   int check;  
  1404.   /**
  1405.    * SELECT MAX(time) FROM GL WHERE account_type = @accountType and purged=1
  1406.    */
  1407.   NdbConnection* pScanTrans = m_ndb.startTransaction();
  1408.   if (pScanTrans == NULL) {
  1409.     ERR(m_ndb.getNdbError());
  1410.     return NDBT_FAILED;
  1411.   }
  1412.       
  1413.   NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("GL");
  1414.   if (pOp == NULL) {
  1415.     ERR(pScanTrans->getNdbError());
  1416.     m_ndb.closeTransaction(pScanTrans);
  1417.     return NDBT_FAILED;
  1418.   }
  1420.   NdbResultSet * rs = pOp->readTuples();
  1421.   if( rs == 0 ) {
  1422.     ERR(pScanTrans->getNdbError());
  1423.     m_ndb.closeTransaction(pScanTrans);
  1424.     return NDBT_FAILED;
  1425.   }
  1427.   check = pOp->interpret_exit_ok();
  1428.   if( check == -1 ) {
  1429.     ERR(pScanTrans->getNdbError());
  1430.     m_ndb.closeTransaction(pScanTrans);
  1431.     return NDBT_FAILED;
  1432.   }
  1434.   NdbRecAttr* accountTypeRec = pOp->getValue("ACCOUNT_TYPE");
  1435.   if( accountTypeRec ==NULL ) {
  1436.     ERR(pScanTrans->getNdbError());
  1437.     m_ndb.closeTransaction(pScanTrans);
  1438.     return NDBT_FAILED;
  1439.   }
  1441.   NdbRecAttr* timeRec = pOp->getValue("TIME");
  1442.   if( timeRec ==NULL ) {
  1443.     ERR(pScanTrans->getNdbError());
  1444.     m_ndb.closeTransaction(pScanTrans);
  1445.     return NDBT_FAILED;
  1446.   }
  1448.   NdbRecAttr* purgedRec = pOp->getValue("PURGED");
  1449.   if( purgedRec ==NULL ) {
  1450.     ERR(pScanTrans->getNdbError());
  1451.     m_ndb.closeTransaction(pScanTrans);
  1452.     return NDBT_FAILED;
  1453.   }
  1455.   check = pScanTrans->execute(NoCommit);
  1456.   if( check == -1 ) {
  1457.     ERR(pScanTrans->getNdbError());
  1458.     m_ndb.closeTransaction(pScanTrans);
  1459.     return NDBT_FAILED;
  1460.   }
  1461.     
  1462.   int eof;
  1463.   int rows = 0;
  1464.   eof = rs->nextResult();
  1465.   oldest = 0;
  1466.     
  1467.   while(eof == 0){
  1468.     rows++;
  1469.     Uint32 a = accountTypeRec->u_32_value();
  1470.     Uint32 p = purgedRec->u_32_value();
  1472.     if (a == accountType && p == 1){
  1473.       // One record found
  1474.       Uint64 t = timeRec->u_64_value();
  1475.       if (t > oldest)
  1476. oldest = t;
  1477.     }
  1478.     eof = rs->nextResult();
  1479.   }
  1480.   if (eof == -1) {
  1481.     ERR(pScanTrans->getNdbError());
  1482.     m_ndb.closeTransaction(pScanTrans);
  1483.     return NDBT_FAILED;
  1484.   }
  1485.     
  1486.   m_ndb.closeTransaction(pScanTrans);
  1487.   
  1488.   return NDBT_OK;
  1489. }
  1491. int Bank::getOldestNotPurgedGL(Uint64 &oldest,
  1492.        Uint32 &accountTypeId,
  1493.        bool &found){
  1494.   int check;  
  1495.   /**
  1496.    * SELECT time, accountTypeId FROM GL 
  1497.    * WHERE purged=0 order by time asc
  1498.    */
  1499.   NdbConnection* pScanTrans = m_ndb.startTransaction();
  1500.   if (pScanTrans == NULL) {
  1501.     ERR(m_ndb.getNdbError());
  1502.     return NDBT_FAILED;
  1503.   }
  1504.       
  1505.   NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("GL");
  1506.   if (pOp == NULL) {
  1507.     ERR(pScanTrans->getNdbError());
  1508.     m_ndb.closeTransaction(pScanTrans);
  1509.     return NDBT_FAILED;
  1510.   }
  1512.   NdbResultSet * rs = pOp->readTuples();
  1513.   if( rs == 0 ) {
  1514.     ERR(pScanTrans->getNdbError());
  1515.     m_ndb.closeTransaction(pScanTrans);
  1516.     return NDBT_FAILED;
  1517.   }
  1519.   check = pOp->interpret_exit_ok();
  1520.   if( check == -1 ) {
  1521.     ERR(pScanTrans->getNdbError());
  1522.     m_ndb.closeTransaction(pScanTrans);
  1523.     return NDBT_FAILED;
  1524.   }
  1526.   NdbRecAttr* accountTypeRec = pOp->getValue("ACCOUNT_TYPE");
  1527.   if( accountTypeRec ==NULL ) {
  1528.     ERR(pScanTrans->getNdbError());
  1529.     m_ndb.closeTransaction(pScanTrans);
  1530.     return NDBT_FAILED;
  1531.   }
  1533.   NdbRecAttr* timeRec = pOp->getValue("TIME");
  1534.   if( timeRec ==NULL ) {
  1535.     ERR(pScanTrans->getNdbError());
  1536.     m_ndb.closeTransaction(pScanTrans);
  1537.     return NDBT_FAILED;
  1538.   }
  1540.   NdbRecAttr* purgedRec = pOp->getValue("PURGED");
  1541.   if( purgedRec ==NULL ) {
  1542.     ERR(pScanTrans->getNdbError());
  1543.     m_ndb.closeTransaction(pScanTrans);
  1544.     return NDBT_FAILED;
  1545.   }
  1547.   check = pScanTrans->execute(NoCommit);
  1548.   if( check == -1 ) {
  1549.     ERR(pScanTrans->getNdbError());
  1550.     m_ndb.closeTransaction(pScanTrans);
  1551.     return NDBT_FAILED;
  1552.   }
  1553.     
  1554.   int eof;
  1555.   int rows = 0;
  1556.   eof = rs->nextResult();
  1557.   oldest = (Uint64)-1;
  1558.   found = false;
  1559.     
  1560.   while(eof == 0){
  1561.     rows++;
  1562.     Uint32 p = purgedRec->u_32_value();
  1563.     if (p == 0){
  1564.       found = true;
  1565.       // One record found
  1566.       Uint32 a = accountTypeRec->u_32_value();      
  1567.       Uint64 t = timeRec->u_64_value();
  1568.       if (t < oldest){
  1569. oldest = t;
  1570. accountTypeId = a;
  1571.       }
  1572.     }
  1573.     eof = rs->nextResult();
  1574.   }
  1575.   if (eof == -1) {
  1576.     ERR(pScanTrans->getNdbError());
  1577.     m_ndb.closeTransaction(pScanTrans);
  1578.     return NDBT_FAILED;
  1579.   }
  1580.     
  1581.   m_ndb.closeTransaction(pScanTrans);
  1583.   return NDBT_OK;
  1584. }
  1587. int Bank::checkNoTransactionsOlderThan(const Uint32 accountType,
  1588.        const Uint64 oldest){
  1589.   /**
  1590.    * SELECT COUNT(transaction_id) FROM TRANSACTION 
  1591.    * WHERE account_type = @accountType and time <= @oldest
  1592.    *
  1593.    */
  1595.   int check;  
  1596.   NdbConnection* pScanTrans = m_ndb.startTransaction();
  1597.   if (pScanTrans == NULL) {
  1598.     ERR(m_ndb.getNdbError());
  1599.     return NDBT_FAILED;
  1600.   }
  1601.       
  1602.   NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("TRANSACTION");
  1603.   if (pOp == NULL) {
  1604.     ERR(pScanTrans->getNdbError());
  1605.     m_ndb.closeTransaction(pScanTrans);
  1606.     return NDBT_FAILED;
  1607.   }
  1609.   NdbResultSet * rs = pOp->readTuples();
  1610.   if( rs == 0 ) {
  1611.     ERR(pScanTrans->getNdbError());
  1612.     m_ndb.closeTransaction(pScanTrans);
  1613.     return NDBT_FAILED;
  1614.   }
  1616.   check = pOp->interpret_exit_ok();
  1617.   if( check == -1 ) {
  1618.     ERR(pScanTrans->getNdbError());
  1619.     m_ndb.closeTransaction(pScanTrans);
  1620.     return NDBT_FAILED;
  1621.   }
  1623.   NdbRecAttr* accountTypeRec = pOp->getValue("ACCOUNT_TYPE");
  1624.   if( accountTypeRec ==NULL ) {
  1625.     ERR(pScanTrans->getNdbError());
  1626.     m_ndb.closeTransaction(pScanTrans);
  1627.     return NDBT_FAILED;
  1628.   }
  1630.   NdbRecAttr* timeRec = pOp->getValue("TIME");
  1631.   if( timeRec ==NULL ) {
  1632.     ERR(pScanTrans->getNdbError());
  1633.     m_ndb.closeTransaction(pScanTrans);
  1634.     return NDBT_FAILED;
  1635.   }
  1637.   NdbRecAttr* transactionIdRec = pOp->getValue("TRANSACTION_ID");
  1638.   if( transactionIdRec ==NULL ) {
  1639.     ERR(pScanTrans->getNdbError());
  1640.     m_ndb.closeTransaction(pScanTrans);
  1641.     return NDBT_FAILED;
  1642.   }
  1644.   check = pScanTrans->execute(NoCommit);   
  1645.   if( check == -1 ) {
  1646.     ERR(pScanTrans->getNdbError());
  1647.     m_ndb.closeTransaction(pScanTrans);
  1648.     return NDBT_FAILED;
  1649.   }
  1650.     
  1651.   int eof;
  1652.   int rows = 0;
  1653.   int found = 0;
  1654.   eof = rs->nextResult();
  1655.     
  1656.   while(eof == 0){
  1657.     rows++;
  1658.     Uint32 a = accountTypeRec->u_32_value();
  1659.     Uint32 t = timeRec->u_32_value();
  1661.     if (a == accountType && t <= oldest){
  1662.       // One record found
  1663.       Uint64 ti = transactionIdRec->u_64_value();
  1664.       g_err << "checkNoTransactionsOlderThan found one record" << endl
  1665.     << "  t = " << t << endl
  1666.     << "  a = " << a << endl
  1667.     << "  ti = " << ti << endl;
  1668.       found++;
  1669.     }
  1670.     eof = rs->nextResult();
  1671.   }
  1672.   if (eof == -1) {
  1673.     ERR(pScanTrans->getNdbError());
  1674.     m_ndb.closeTransaction(pScanTrans);
  1675.     return NDBT_FAILED;
  1676.   }
  1677.     
  1678.   m_ndb.closeTransaction(pScanTrans);
  1679.   
  1680.   if (found == 0)
  1681.     return NDBT_OK;
  1682.   else
  1683.     return VERIFICATION_FAILED;
  1684. }
  1687.  int Bank::performValidatePurged(){
  1688.    /**
  1689.     * Make sure there are no TRANSACTIONS older than the oldest 
  1690.     * purged GL record
  1691.     * 
  1692.     */
  1694.    for (int i = 0; i < getNumAccountTypes(); i++){
  1695.      ndbout << "performValidatePurged: " << i << endl;
  1696.      Uint64 oldestGlTime; 
  1697.      if (getOldestPurgedGL(i, oldestGlTime) != NDBT_OK){
  1698.        g_err << "getOldestPurgedGL failed" << endl;
  1699.        return NDBT_FAILED;    
  1700.      }
  1701.      int result = checkNoTransactionsOlderThan(i, oldestGlTime);
  1702.      if (result != NDBT_OK){
  1703.        g_err << "checkNoTransactionsOlderThan failed" << endl;
  1704.        return result;
  1705.      }
  1706.      
  1707.    }
  1708.    
  1709.    return NDBT_OK;
  1710.  }
  1712.  int Bank::purgeOldGLTransactions(Uint64 currTime, Uint32 age){
  1713.    /** 
  1714.     * For each GL record that are older than age and have purged == 0
  1715.     *  - delete all TRANSACTIONS belonging to the GL and set purged = 1
  1716.     *
  1717.     * 
  1718.     */
  1719.    bool found;
  1720.    int count = 0;
  1722.    while(1){
  1723.      count++;
  1724.      if (count > 100)
  1725.        return NDBT_OK;
  1726.      
  1727.      // Search for the oldest GL record with purged == 0
  1728.      Uint64 oldestGlTime;
  1729.      Uint32 accountTypeId;
  1730.      if (getOldestNotPurgedGL(oldestGlTime, accountTypeId, found) != NDBT_OK){
  1731.        g_err << "getOldestNotPurgedGL failed" << endl;
  1732.        return NDBT_FAILED;
  1733.      }
  1736.      if (found == false){
  1737.        // ndbout << "not found" << endl;
  1738.        return NDBT_OK;
  1739.      }
  1741.      
  1742. //      ndbout << "purgeOldGLTransactions" << endl
  1743. //           << "  oldestGlTime = " << oldestGlTime << endl
  1744. //           << "  currTime = " << currTime << endl
  1745. //      << "  age = " << age << endl;
  1746.      // Check if this GL is old enough to be purged
  1747.      if ((currTime < age) || (oldestGlTime > (currTime-age))){
  1748.        //       ndbout << "is not old enough" << endl;
  1749.        return NDBT_OK;
  1750.      }
  1752.      if (purgeTransactions(oldestGlTime, accountTypeId) != NDBT_OK){
  1753.        g_err << "purgeTransactions failed" << endl;
  1754.        return NDBT_FAILED;
  1755.      }
  1756.    }
  1757.    g_err << "abnormal return" << endl; 
  1758.    return NDBT_FAILED;
  1759.  }
  1760.  
  1762. int Bank::purgeTransactions(const Uint64 glTime, 
  1763.     const Uint32 accountTypeId)
  1764. {
  1765.   int check;
  1766.   g_info << "purgeTransactions: " << glTime << ", "<<accountTypeId<<endl;
  1767.   NdbConnection* pTrans = m_ndb.startTransaction();
  1768.   if (pTrans == NULL){
  1769.     ERR(m_ndb.getNdbError());
  1770.     return NDBT_FAILED;
  1771.   }
  1773.   // Start by updating the GL record with purged = 1, use NoCommit
  1774.   NdbOperation* pOp = pTrans->getNdbOperation("GL");
  1775.   if (pOp == NULL) {
  1776.     ERR(pTrans->getNdbError());
  1777.     return NDBT_FAILED;
  1778.   }
  1779.     
  1780.   check = pOp->updateTuple();
  1781.   if( check == -1 ) {
  1782.     ERR(pTrans->getNdbError());
  1783.     return NDBT_FAILED;
  1784.   }
  1785.       
  1786.   check = pOp->equal("TIME", glTime);
  1787.   if( check == -1 ) {
  1788.     ERR(pTrans->getNdbError());
  1789.     return NDBT_FAILED;
  1790.   }
  1792.   check = pOp->equal("ACCOUNT_TYPE", accountTypeId);
  1793.   if( check == -1 ) {
  1794.     ERR(pTrans->getNdbError());
  1795.     return NDBT_FAILED;
  1796.   }
  1798.   Uint32 purged = 1;
  1799.   check = pOp->setValue("PURGED", purged);
  1800.   if( check == -1 ) {
  1801.     ERR(pTrans->getNdbError());
  1802.     return NDBT_FAILED;
  1803.   }
  1805.   // Execute transaction    
  1806.   check = pTrans->execute(NoCommit);
  1807.   if( check == -1 ) {
  1808.     ERR(pTrans->getNdbError());
  1809.     return NDBT_FAILED;
  1810.   }    
  1812.   // Find all transactions and take over them for delete
  1814.   if(findTransactionsToPurge(glTime,
  1815.     accountTypeId,
  1816.     pTrans) != NDBT_OK){
  1817.     g_err << "findTransactionToPurge failed" << endl;
  1818.     m_ndb.closeTransaction(pTrans);
  1819.     return NDBT_FAILED;
  1820.   }
  1824.   check = pTrans->execute(Commit);
  1825.   if( check == -1 ) {
  1826.     ERR(pTrans->getNdbError());
  1827.     return NDBT_FAILED;
  1828.   } 
  1830.   m_ndb.closeTransaction(pTrans);
  1831.   return NDBT_OK;
  1832. }
  1835. int Bank::findTransactionsToPurge(const Uint64 glTime, 
  1836.   const Uint32 accountType,
  1837.   NdbConnection* pTrans){
  1838.   int check;
  1839.   
  1840.   NdbConnection* pScanTrans = m_ndb.startTransaction();
  1841.   if (pScanTrans == NULL) {
  1842.     ERR(m_ndb.getNdbError());
  1843.     return NDBT_FAILED;
  1844.   }
  1845.       
  1846.   NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("TRANSACTION");
  1847.   if (pOp == NULL) {
  1848.     ERR(pScanTrans->getNdbError());
  1849.     m_ndb.closeTransaction(pScanTrans);
  1850.     return NDBT_FAILED;
  1851.   }
  1853.   NdbResultSet * rs = pOp->readTuplesExclusive();
  1854.   if( rs == 0 ) {
  1855.     ERR(pScanTrans->getNdbError());
  1856.     m_ndb.closeTransaction(pScanTrans);
  1857.     return NDBT_FAILED;
  1858.   }
  1860.   check = pOp->interpret_exit_ok();
  1861.   if( check == -1 ) {
  1862.     ERR(pScanTrans->getNdbError());
  1863.     m_ndb.closeTransaction(pScanTrans);
  1864.     return NDBT_FAILED;
  1865.   }
  1867.   NdbRecAttr* timeRec = pOp->getValue("TIME");
  1868.   if( timeRec ==NULL ) {
  1869.     ERR(pScanTrans->getNdbError());
  1870.     m_ndb.closeTransaction(pScanTrans);
  1871.     return NDBT_FAILED;
  1872.   }
  1874.   NdbRecAttr* accountTypeRec = pOp->getValue("ACCOUNT_TYPE");
  1875.   if( accountTypeRec ==NULL ) {
  1876.     ERR(pScanTrans->getNdbError());
  1877.     m_ndb.closeTransaction(pScanTrans);
  1878.     return NDBT_FAILED;
  1879.   }
  1881.   check = pScanTrans->execute(NoCommit);   
  1882.   if( check == -1 ) {
  1883.     ERR(pScanTrans->getNdbError());
  1884.     m_ndb.closeTransaction(pScanTrans);
  1885.     return NDBT_FAILED;
  1886.   }
  1887.     
  1888.   int eof;
  1889.   int rows = 0;
  1890.   int rowsFound = 0;
  1891.   eof = rs->nextResult();
  1892.     
  1893.   while(eof == 0){
  1894.     rows++;
  1895.     Uint64 t = timeRec->u_64_value();
  1896.     Uint32 a = accountTypeRec->u_32_value();
  1898.     if (a == accountType && t == glTime){
  1899.       rowsFound++;
  1900.       // One record found
  1901.       check = rs->deleteTuple(pTrans);
  1902.       if (check == -1){
  1903. ERR(m_ndb.getNdbError());
  1904. m_ndb.closeTransaction(pScanTrans);
  1905. return NDBT_FAILED;
  1906.       }
  1907.       
  1908.       // Execute transaction    
  1909.       check = pTrans->execute(NoCommit);
  1910.       if( check == -1 ) {
  1911. ERR(pTrans->getNdbError());
  1912. m_ndb.closeTransaction(pScanTrans);
  1913. return NDBT_FAILED;
  1914.       }       
  1915.     }
  1916.     eof = rs->nextResult();
  1917.   }
  1918.   if (eof == -1) {
  1919.     ERR(pScanTrans->getNdbError());
  1920.     m_ndb.closeTransaction(pScanTrans);
  1921.     return NDBT_FAILED;
  1922.   }
  1923.     
  1924.   m_ndb.closeTransaction(pScanTrans);
  1925.   //  ndbout << rowsFound << " TRANSACTIONS have been deleted" << endl;
  1927.   return NDBT_OK;
  1929. }
  1930.  
  1931.  
  1932. int Bank::performIncreaseTime(int maxSleepBetweenDays, int yield)
  1933. {
  1934.   int yieldCounter = 0;
  1935.   
  1936.   while(1){
  1937.     
  1938.     Uint64 currTime;
  1939.     if (incCurrTime(currTime) != NDBT_OK)
  1940.       break;
  1941.     
  1942.     g_info << "Current time is " << currTime << endl;
  1943.     if (maxSleepBetweenDays > 0){
  1944.       int val = myRandom48(maxSleepBetweenDays);
  1945.       NdbSleep_SecSleep(val);
  1946.     }
  1947.     
  1948.     yieldCounter++;
  1949.     if (yield != 0 && yieldCounter >= yield)
  1950.       return NDBT_OK;
  1951.     
  1952.   }
  1953.   return NDBT_FAILED;
  1954. }
  1956. int Bank::readSystemValue(SystemValueId sysValId, Uint64 & value){
  1958.   int check;
  1959.     
  1960.   NdbConnection* pTrans = m_ndb.startTransaction();
  1961.   if (pTrans == NULL){
  1962.     ERR(m_ndb.getNdbError());
  1963.     if(m_ndb.getNdbError().status == NdbError::TemporaryError)
  1964.       return NDBT_TEMPORARY;
  1965.     return NDBT_FAILED;
  1966.   }
  1968.   int result;
  1969.   if ((result= prepareReadSystemValueOp(pTrans, sysValId, value)) != NDBT_OK) {
  1970.     ERR(pTrans->getNdbError());
  1971.     m_ndb.closeTransaction(pTrans);
  1972.     return result;
  1973.   }
  1975.   check = pTrans->execute(Commit);
  1976.   if( check == -1 ) {
  1977.     ERR(pTrans->getNdbError());
  1978.     if(pTrans->getNdbError().status == NdbError::TemporaryError)
  1979.     {
  1980.       m_ndb.closeTransaction(pTrans);
  1981.       return NDBT_TEMPORARY;
  1982.     }
  1983.     m_ndb.closeTransaction(pTrans);
  1984.     return NDBT_FAILED;
  1985.   }
  1986.   
  1987.   m_ndb.closeTransaction(pTrans);      
  1988.   return NDBT_OK;
  1990. }
  1992. int Bank::prepareReadSystemValueOp(NdbConnection* pTrans, SystemValueId sysValId, Uint64 & value){
  1994.   int check;
  1995.     
  1996.   NdbOperation* pOp = pTrans->getNdbOperation("SYSTEM_VALUES");
  1997.   if (pOp == NULL) {
  1998.     return NDBT_FAILED;
  1999.   }
  2000.     
  2001.   check = pOp->readTuple();
  2002.   if( check == -1 ) {
  2003.     return NDBT_FAILED;
  2004.   }
  2005.     
  2006.   check = pOp->equal("SYSTEM_VALUES_ID", sysValId);
  2007.   if( check == -1 ) {
  2008.     return NDBT_FAILED;
  2009.   }
  2010.     
  2011.   NdbRecAttr* valueRec = pOp->getValue("VALUE", (char *)&value);
  2012.   if( valueRec == NULL ) {
  2013.     return NDBT_FAILED;
  2014.   }
  2015.     
  2016.   return NDBT_OK;
  2017. }
  2019. int Bank::writeSystemValue(SystemValueId sysValId, Uint64 value){
  2021.   int check;
  2022.     
  2023.   NdbConnection* pTrans = m_ndb.startTransaction();
  2024.   if (pTrans == NULL){
  2025.     ERR(m_ndb.getNdbError());
  2026.     return NDBT_FAILED;
  2027.   }
  2028.     
  2029.   NdbOperation* pOp = pTrans->getNdbOperation("SYSTEM_VALUES");
  2030.   if (pOp == NULL) {
  2031.     ERR(pTrans->getNdbError());
  2032.     m_ndb.closeTransaction(pTrans);
  2033.     return NDBT_FAILED;
  2034.   }
  2035.     
  2036.   check = pOp->insertTuple();
  2037.   if( check == -1 ) {
  2038.     ERR(pTrans->getNdbError());
  2039.     m_ndb.closeTransaction(pTrans);
  2040.     return NDBT_FAILED;
  2041.   }
  2042.       
  2043.   check = pOp->equal("SYSTEM_VALUES_ID", sysValId);
  2044.   if( check == -1 ) {
  2045.     ERR(pTrans->getNdbError());
  2046.     m_ndb.closeTransaction(pTrans);
  2047.     return NDBT_FAILED;
  2048.   }
  2050.   check = pOp->setValue("VALUE", value);
  2051.   if( check == -1 ) {
  2052.     ERR(pTrans->getNdbError());
  2053.     m_ndb.closeTransaction(pTrans);
  2054.     return NDBT_FAILED;
  2055.   }
  2057.   check = pTrans->execute(Commit);
  2058.   if( check == -1 ) {
  2059.     ERR(pTrans->getNdbError());
  2060.     m_ndb.closeTransaction(pTrans);
  2061.     return NDBT_FAILED;
  2062.   }
  2063.     
  2064.   m_ndb.closeTransaction(pTrans);      
  2065.   return NDBT_OK;
  2067. }
  2069. int Bank::getNextTransactionId(Uint64 &value){
  2070.   return increaseSystemValue2(LastTransactionId, value);
  2071. }
  2073. int Bank::incCurrTime(Uint64 &value){
  2074.   return increaseSystemValue(CurrentTime, value);
  2075. }
  2077.   
  2078. int Bank::increaseSystemValue(SystemValueId sysValId, Uint64 &value){
  2079.   /**
  2080.    * Increase value with one and return
  2081.    * updated value
  2082.    *
  2083.    */
  2085.   DBUG_ENTER("Bank::increaseSystemValue");
  2087.   int check;
  2088.     
  2089.   NdbConnection* pTrans = m_ndb.startTransaction();
  2090.   if (pTrans == NULL){
  2091.     ERR(m_ndb.getNdbError());
  2092.     if (m_ndb.getNdbError().status == NdbError::TemporaryError)
  2093.       DBUG_RETURN(NDBT_TEMPORARY);
  2094.     DBUG_RETURN(NDBT_FAILED);
  2095.   }
  2096.     
  2097.   NdbOperation* pOp = pTrans->getNdbOperation("SYSTEM_VALUES");
  2098.   if (pOp == NULL) {
  2099.     ERR(pTrans->getNdbError());
  2100.     m_ndb.closeTransaction(pTrans);
  2101.     DBUG_RETURN(NDBT_FAILED);
  2102.   }
  2103.     
  2104.   check = pOp->readTupleExclusive();
  2105.   //  check = pOp->readTuple();
  2106.   if( check == -1 ) {
  2107.     ERR(pTrans->getNdbError());
  2108.     m_ndb.closeTransaction(pTrans);
  2109.     DBUG_RETURN(NDBT_FAILED);
  2110.   }
  2111.     
  2112.   check = pOp->equal("SYSTEM_VALUES_ID", sysValId);
  2113.   if( check == -1 ) {
  2114.     ERR(pTrans->getNdbError());
  2115.     m_ndb.closeTransaction(pTrans);
  2116.     DBUG_RETURN(NDBT_FAILED);
  2117.   }
  2118.     
  2119.   NdbRecAttr* valueRec = pOp->getValue("VALUE");
  2120.   if( valueRec ==NULL ) {
  2121.     ERR(pTrans->getNdbError());
  2122.     m_ndb.closeTransaction(pTrans);
  2123.     DBUG_RETURN(NDBT_FAILED);
  2124.   }
  2125.     
  2126.   check = pTrans->execute(NoCommit);
  2127.   if( check == -1 ) {
  2128.     ERR(pTrans->getNdbError());
  2129.     if (pTrans->getNdbError().status == NdbError::TemporaryError)
  2130.     {
  2131.       m_ndb.closeTransaction(pTrans);
  2132.       DBUG_RETURN(NDBT_TEMPORARY);
  2133.     }
  2134.     m_ndb.closeTransaction(pTrans);
  2135.     DBUG_RETURN(NDBT_FAILED);
  2136.   }
  2137.     
  2138.   value = valueRec->u_64_value();
  2139.   value++;
  2140.     
  2141.   NdbOperation* pOp2 = pTrans->getNdbOperation("SYSTEM_VALUES");
  2142.   if (pOp2 == NULL) {
  2143.     ERR(pTrans->getNdbError());
  2144.     m_ndb.closeTransaction(pTrans);
  2145.     DBUG_RETURN(NDBT_FAILED);
  2146.   }
  2147.     
  2148.   check = pOp2->updateTuple();
  2149.   if( check == -1 ) {
  2150.     ERR(pTrans->getNdbError());
  2151.     m_ndb.closeTransaction(pTrans);
  2152.     DBUG_RETURN(NDBT_FAILED);
  2153.   }
  2154.     
  2155.   check = pOp2->equal("SYSTEM_VALUES_ID", sysValId);
  2156.   if( check == -1 ) {
  2157.     ERR(pTrans->getNdbError());
  2158.     m_ndb.closeTransaction(pTrans);
  2159.     DBUG_RETURN(NDBT_FAILED);
  2160.   }
  2161.     
  2162.   check = pOp2->setValue("VALUE", value);
  2163.   if( check == -1 ) {
  2164.     ERR(pTrans->getNdbError());
  2165.     m_ndb.closeTransaction(pTrans);
  2166.     DBUG_RETURN(NDBT_FAILED);
  2167.   }
  2169.   check = pTrans->execute(NoCommit);
  2170.   if( check == -1 ) {
  2171.     ERR(pTrans->getNdbError());
  2172.     m_ndb.closeTransaction(pTrans);
  2173.     DBUG_RETURN(NDBT_FAILED);
  2174.   }
  2176.   NdbOperation* pOp3 = pTrans->getNdbOperation("SYSTEM_VALUES");
  2177.   if (pOp3 == NULL) {
  2178.     ERR(pTrans->getNdbError());
  2179.     m_ndb.closeTransaction(pTrans);
  2180.     DBUG_RETURN(NDBT_FAILED);
  2181.   }
  2183.   check = pOp3->readTuple();
  2184.   if( check == -1 ) {
  2185.     ERR(pTrans->getNdbError());
  2186.     m_ndb.closeTransaction(pTrans);
  2187.     DBUG_RETURN(NDBT_FAILED);
  2188.   }
  2189.     
  2190.   check = pOp3->equal("SYSTEM_VALUES_ID", sysValId);
  2191.   if( check == -1 ) {
  2192.     ERR(pTrans->getNdbError());
  2193.     m_ndb.closeTransaction(pTrans);
  2194.     DBUG_RETURN(NDBT_FAILED);
  2195.   }
  2197.   // Read new value
  2198.   NdbRecAttr* valueNewRec = pOp3->getValue("VALUE");
  2199.   if( valueNewRec ==NULL ) {
  2200.     ERR(pTrans->getNdbError());
  2201.     m_ndb.closeTransaction(pTrans);
  2202.     DBUG_RETURN(NDBT_FAILED);
  2203.   }
  2205.   check = pTrans->execute(Commit);
  2206.   if( check == -1 ) {
  2207.     ERR(pTrans->getNdbError());
  2208.     if (pTrans->getNdbError().status == NdbError::TemporaryError)
  2209.     {
  2210.       m_ndb.closeTransaction(pTrans);
  2211.       DBUG_RETURN(NDBT_TEMPORARY);
  2212.     }
  2213.     m_ndb.closeTransaction(pTrans);
  2214.     DBUG_RETURN(NDBT_FAILED);
  2215.   }
  2217.   // Check that value updated equals the value we read after the update
  2218.   if (valueNewRec->u_64_value() != value){
  2219.     
  2220.     printf("value actual=%lldn", valueNewRec->u_64_value());
  2221.     printf("value expected=%lld actual=%lldn", value, valueNewRec->u_64_value());
  2222.     
  2223.     DBUG_PRINT("info", ("value expected=%ld actual=%ld", value, valueNewRec->u_64_value()));
  2224.     g_err << "getNextTransactionId: value was not updated" << endl;
  2225.     m_ndb.closeTransaction(pTrans);
  2226.     DBUG_RETURN(NDBT_FAILED);
  2227.   }
  2229.   m_ndb.closeTransaction(pTrans);
  2230.   
  2231.   DBUG_RETURN(0);
  2232. }
  2234. int Bank::increaseSystemValue2(SystemValueId sysValId, Uint64 &value){
  2235.   /**
  2236.    * Increase value with one and return
  2237.    * updated value
  2238.    * A more optimized version using interpreted update!
  2239.    *
  2240.    */
  2242.   int check;
  2243.     
  2244.   NdbConnection* pTrans = m_ndb.startTransaction();
  2245.   if (pTrans == NULL){
  2246.     ERR(m_ndb.getNdbError());
  2247.     if(m_ndb.getNdbError().status == NdbError::TemporaryError)
  2248.       return NDBT_TEMPORARY;
  2249.     return NDBT_FAILED;
  2250.   }
  2251.     
  2252.   NdbOperation* pOp = pTrans->getNdbOperation("SYSTEM_VALUES");
  2253.   if (pOp == NULL) {
  2254.     ERR(pTrans->getNdbError());
  2255.     m_ndb.closeTransaction(pTrans);
  2256.     return NDBT_FAILED;
  2257.   }
  2259.   check = pOp->interpretedUpdateTuple();
  2260.   if( check == -1 ) {
  2261.     ERR(pTrans->getNdbError());
  2262.     m_ndb.closeTransaction(pTrans);
  2263.     return NDBT_FAILED;
  2264.   }
  2266.   check = pOp->equal("SYSTEM_VALUES_ID", sysValId );
  2267.   if( check == -1 ) {
  2268.     ERR(pTrans->getNdbError());
  2269.     m_ndb.closeTransaction(pTrans);
  2270.     return NDBT_FAILED;
  2271.   }
  2273.   Uint32 valToIncWith = 1;
  2274.   check = pOp->incValue("VALUE", valToIncWith);
  2275.   if( check == -1 ) {
  2276.     ERR(pTrans->getNdbError());
  2277.     m_ndb.closeTransaction(pTrans);
  2278.     return NDBT_FAILED;
  2279.   }
  2281.   NdbRecAttr* valueRec = pOp->getValue("VALUE");
  2282.   if( valueRec == NULL ) {
  2283.     ERR(pTrans->getNdbError());
  2284.     m_ndb.closeTransaction(pTrans);
  2285.     return NDBT_FAILED;
  2286.   }
  2287.   
  2288.   check = pTrans->execute(Commit);
  2289.   if( check == -1 ) {
  2290.     ERR(pTrans->getNdbError());
  2291.     if(pTrans->getNdbError().status == NdbError::TemporaryError)
  2292.     {
  2293.       m_ndb.closeTransaction(pTrans);
  2294.       return NDBT_TEMPORARY;
  2295.     }
  2296.     m_ndb.closeTransaction(pTrans);
  2297.     return NDBT_FAILED;
  2298.   }
  2300.   value = valueRec->u_64_value();
  2301.     
  2302.   m_ndb.closeTransaction(pTrans);
  2304.   return 0;
  2306. }
  2310. int Bank::getCurrTime(Uint64 &time){
  2311.   return readSystemValue(CurrentTime, time);
  2312. }
  2314. int Bank::prepareGetCurrTimeOp(NdbConnection *pTrans, Uint64 &time){
  2315.   return prepareReadSystemValueOp(pTrans, CurrentTime, time);
  2316. }
  2319. int Bank::performSumAccounts(int maxSleepBetweenSums, int yield){
  2320.   
  2321.   int yieldCounter = 0;
  2323.   while (1){
  2325.     Uint32 sumAccounts = 0;
  2326.     Uint32 numAccounts = 0;
  2327.     if (getSumAccounts(sumAccounts, numAccounts) != NDBT_OK){
  2328.       g_err << "getSumAccounts FAILED" << endl;
  2329.     } else {
  2330.     
  2331.       g_info << "num="<<numAccounts<<", sum=" << sumAccounts << endl;
  2332.       
  2333.       if (sumAccounts != (10000000 + (10000*(numAccounts-1)))){
  2334. g_err << "performSumAccounts  FAILED" << endl
  2335.       << "   sumAccounts="<<sumAccounts<<endl
  2336.       << "   expected   ="<<(10000000 + (10000*(numAccounts-1)))<<endl
  2337.       << "   numAccounts="<<numAccounts<<endl;
  2338. return NDBT_FAILED;
  2339.       } 
  2340.     
  2341.       if (maxSleepBetweenSums > 0){
  2342. int val = myRandom48(maxSleepBetweenSums);
  2343. NdbSleep_MilliSleep(val);      
  2344.       }
  2345.     }
  2347.     yieldCounter++;
  2348.     if (yield != 0 && yieldCounter >= yield)
  2349.       return NDBT_OK;
  2350.   }
  2351.   return NDBT_FAILED;
  2352. }
  2355. int Bank::getSumAccounts(Uint32 &sumAccounts, 
  2356.  Uint32 &numAccounts){
  2358.   // SELECT SUM(balance) FROM ACCOUNT
  2360.   int check;    
  2361.   NdbConnection* pScanTrans = m_ndb.startTransaction();
  2362.   if (pScanTrans == NULL) {
  2363.     ERR(m_ndb.getNdbError());
  2364.     return NDBT_FAILED;
  2365.   }
  2367.   NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("ACCOUNT");
  2368.   if (pOp == NULL) {
  2369.     ERR(pScanTrans->getNdbError());
  2370.     m_ndb.closeTransaction(pScanTrans);
  2371.     return NDBT_FAILED;
  2372.   }
  2374.   NdbResultSet * rs = pOp->readTuplesExclusive();
  2375.   if( rs == 0 ) {
  2376.     ERR(pScanTrans->getNdbError());
  2377.     m_ndb.closeTransaction(pScanTrans);
  2378.     return NDBT_FAILED;
  2379.   }
  2381.   check = pOp->interpret_exit_ok();
  2382.   if( check == -1 ) {
  2383.     ERR(pScanTrans->getNdbError());
  2384.     m_ndb.closeTransaction(pScanTrans);
  2385.     return NDBT_FAILED;
  2386.   }
  2388.   NdbRecAttr* balanceRec = pOp->getValue("BALANCE");
  2389.   if( balanceRec ==NULL ) {
  2390.     ERR(pScanTrans->getNdbError());
  2391.     m_ndb.closeTransaction(pScanTrans);
  2392.     return NDBT_FAILED;
  2393.   }
  2395.   check = pScanTrans->execute(NoCommit);   
  2396.   if( check == -1 ) {
  2397.     ERR(pScanTrans->getNdbError());
  2398.     m_ndb.closeTransaction(pScanTrans);
  2399.     return NDBT_FAILED;
  2400.   }
  2402.   NdbConnection* pTrans = m_ndb.startTransaction();
  2403.   if (pTrans == NULL) {
  2404.     ERR(m_ndb.getNdbError());
  2405.     m_ndb.closeTransaction(pScanTrans);
  2406.     return NDBT_FAILED;
  2407.   }   
  2409.   int eof;
  2410.   eof = rs->nextResult();
  2411.     
  2412.   while(eof == 0){
  2413.     Uint32 b = balanceRec->u_32_value();
  2414.     
  2415.     sumAccounts += b;
  2416.     numAccounts++;
  2418.     //    ndbout << numAccounts << ": balance =" << b 
  2419.     //    << ", sum="<< sumAccounts << endl;
  2421.     // Take over the operation so that the lock is kept in db
  2422.     NdbOperation* pLockOp = rs->updateTuple(pTrans);
  2423.     if (pLockOp == NULL){
  2424.       ERR(m_ndb.getNdbError());
  2425.       m_ndb.closeTransaction(pScanTrans);
  2426.       m_ndb.closeTransaction(pTrans);
  2427.       return NDBT_FAILED;
  2428.     }
  2429.     
  2430.     Uint32 illegalBalance = 99;
  2431.     check = pLockOp->setValue("BALANCE", illegalBalance);
  2432.     if( check == -1 ) {
  2433.       ERR(pTrans->getNdbError());
  2434.       m_ndb.closeTransaction(pTrans);
  2435.       m_ndb.closeTransaction(pScanTrans);
  2436.       return NDBT_FAILED;
  2437.     }
  2438.     
  2439.     // Execute transaction    
  2440.     check = pTrans->execute(NoCommit);
  2441.     if( check == -1 ) {
  2442.       ERR(pTrans->getNdbError());
  2443.       m_ndb.closeTransaction(pScanTrans);
  2444.       m_ndb.closeTransaction(pTrans);
  2445.       return NDBT_FAILED;
  2446.     }       
  2448.     eof = rs->nextResult();
  2449.   }
  2450.   if (eof == -1) {
  2451.     ERR(pScanTrans->getNdbError());
  2452.     m_ndb.closeTransaction(pScanTrans);
  2453.     m_ndb.closeTransaction(pTrans);
  2454.     return NDBT_FAILED;
  2455.   }
  2457.   // TODO Forget about rolling back, just close pTrans!!
  2459.   // Rollback transaction    
  2460.   check = pTrans->execute(Rollback);
  2461.   if( check == -1 ) {
  2462.     ERR(pTrans->getNdbError());
  2463.     m_ndb.closeTransaction(pScanTrans);
  2464.     m_ndb.closeTransaction(pTrans);
  2465.     return NDBT_FAILED;
  2466.   }       
  2467.     
  2468.   m_ndb.closeTransaction(pScanTrans);
  2469.   m_ndb.closeTransaction(pTrans);
  2472.   return NDBT_OK;
  2474. }