release/src/router/mysql/storage/ndb/test/ndbapi/bank/Bank.cpp

   1 /* Copyright (c) 2003-2006 MySQL AB
   2
   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; version 2 of the License.
   6
   7    This program is distributed in the hope that it will be useful,
   8    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10    GNU General Public License for more details.
  11
  12    You should have received a copy of the GNU General Public License
  13    along with this program; if not, write to the Free Software
  14    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA */
  15
  16 #include "Bank.hpp"
  17 #include <time.h>
  18 #include <NdbSleep.h>
  19 #include <UtilTransactions.hpp>
  20
  21 Bank::Bank(Ndb_cluster_connection& con, bool _init, const char * dbase):
  22   m_ndb(&con, dbase),
  23   m_maxAccount(-1),
  24   m_initialized(false),
  25   m_skip_create(false)
  26 {
  27   if(_init)
  28     init();
  29 }
  30
  31 int Bank::init(){
  32   if (m_initialized == true)
  33     return NDBT_OK;
  34
  35   myRandom48Init(NdbTick_CurrentMillisecond());
  36
  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;
  46
  47   m_initialized = true;
  48   return NDBT_OK;
  49 }
  50
  51 int Bank::performTransactions(int maxSleepBetweenTrans, int yield){
  52
  53   int transactions = 0;
  54
  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   }
  70
  71   return NDBT_FAILED;
  72
  73 }
  74
  75 int Bank::performTransaction(){
  76   int result = NDBT_OK;
  77
  78   if (m_maxAccount <= 0){
  79     g_err << "No accounts in bank" << endl;
  80     return NDBT_FAILED;
  81   }
  82
  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);
  94
  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       NdbSleep_MilliSleep(50);
 112       goto retry_transaction;
 113       break;
 114     default:
 115       g_info << "performTransaction returned "<<res << endl;
 116       break;
 117     }
 118   }
 119   return result;
 120 }
 121
 122 /**
 123  * Perform a transaction in the bank.
 124  * Ie. transfer money from one account to another.
 125  *
 126  * @param
 127  * @return 0 if successful or an error code
 128  */
 129 int Bank::performTransaction(int fromAccountId,
 130                              int toAccountId,
 131                              int amount ){
 132   /**
 133    * 1. Start transaction
 134    * 2. Check balance on from account, if there is
 135    *    not enough funds abort transaction
 136    * 3. Update ACCOUNT set balance = balance - amount on
 137    *    from account
 138    * 4. Insert withdrawal in TRANSACTION
 139    * 5. Insert deposit in transaction
 140    * 6. Update ACCOUNT set balance = balance + amount on
 141    *    to account
 142    * 7. Commit transaction
 143    */
 144   //  g_info << "performTransaction " << fromAccountId
 145   //     << ", "<<toAccountId<<", "<<amount << endl;
 146
 147   // Call the first implementation of this trans
 148   // In the future we can have several different versions of this trans
 149   // and call them randomly
 150   return performTransactionImpl1(fromAccountId, toAccountId, amount);
 151 }
 152
 153
 154 int Bank::performTransactionImpl1(int fromAccountId,
 155                                   int toAccountId,
 156                                   int amount ){
 157
 158   int check;
 159
 160   // Ok, all clear to do the transaction
 161   Uint64 transId;
 162   int result = NDBT_OK;
 163   if ((result= getNextTransactionId(transId)) != NDBT_OK){
 164     return result;
 165   }
 166
 167   NdbConnection* pTrans = m_ndb.startTransaction();
 168
 169   if( pTrans == NULL ) {
 170     const NdbError err = m_ndb.getNdbError();
 171     if (err.status == NdbError::TemporaryError){
 172       ERR(err);
 173       return NDBT_TEMPORARY;
 174     }
 175     ERR(err);
 176     return NDBT_FAILED;
 177   }
 178
 179   Uint64 currTime;
 180   if (prepareGetCurrTimeOp(pTrans, currTime) != NDBT_OK){
 181     ERR(pTrans->getNdbError());
 182     m_ndb.closeTransaction(pTrans);
 183     return NDBT_FAILED;
 184   }
 185
 186   /**
 187    * Check balance on from account
 188    */
 189   NdbOperation* pOp = pTrans->getNdbOperation("ACCOUNT");
 190   if (pOp == NULL) {
 191     ERR(pTrans->getNdbError());
 192     m_ndb.closeTransaction(pTrans);
 193     return NDBT_FAILED;
 194   }
 195
 196   check = pOp->readTupleExclusive();
 197   if( check == -1 ) {
 198     ERR(pTrans->getNdbError());
 199     m_ndb.closeTransaction(pTrans);
 200     return NDBT_FAILED;
 201   }
 202
 203   check = pOp->equal("ACCOUNT_ID", fromAccountId);
 204   if( check == -1 ) {
 205     ERR(pTrans->getNdbError());
 206     m_ndb.closeTransaction(pTrans);
 207     return NDBT_FAILED;
 208   }
 209
 210   NdbRecAttr* balanceFromRec = pOp->getValue("BALANCE");
 211   if( balanceFromRec ==NULL ) {
 212     ERR(pTrans->getNdbError());
 213     m_ndb.closeTransaction(pTrans);
 214     return NDBT_FAILED;
 215   }
 216
 217   NdbRecAttr* fromAccountTypeRec = pOp->getValue("ACCOUNT_TYPE");
 218   if( fromAccountTypeRec == NULL ) {
 219     ERR(pTrans->getNdbError());
 220     m_ndb.closeTransaction(pTrans);
 221     return NDBT_FAILED;
 222   }
 223
 224   /**
 225    * Read balance on to account
 226    */
 227   NdbOperation* pOp6 = pTrans->getNdbOperation("ACCOUNT");
 228   if (pOp6 == NULL) {
 229     ERR(pTrans->getNdbError());
 230     m_ndb.closeTransaction(pTrans);
 231     return NDBT_FAILED;
 232   }
 233
 234   check = pOp6->readTupleExclusive();
 235   if( check == -1 ) {
 236     ERR(pTrans->getNdbError());
 237     m_ndb.closeTransaction(pTrans);
 238     return NDBT_FAILED;
 239   }
 240
 241   check = pOp6->equal("ACCOUNT_ID", toAccountId);
 242   if( check == -1 ) {
 243     ERR(pTrans->getNdbError());
 244     m_ndb.closeTransaction(pTrans);
 245     return NDBT_FAILED;
 246   }
 247
 248   NdbRecAttr* balanceToRec = pOp6->getValue("BALANCE");
 249   if( balanceToRec == NULL ) {
 250     ERR(pTrans->getNdbError());
 251     m_ndb.closeTransaction(pTrans);
 252     return NDBT_FAILED;
 253   }
 254
 255   NdbRecAttr* toAccountTypeRec = pOp6->getValue("ACCOUNT_TYPE");
 256   if( toAccountTypeRec == NULL ) {
 257     ERR(pTrans->getNdbError());
 258     m_ndb.closeTransaction(pTrans);
 259     return NDBT_FAILED;
 260   }
 261
 262   check = pTrans->execute(NoCommit);
 263   if( check == -1 ) {
 264     const NdbError err = pTrans->getNdbError();
 265     m_ndb.closeTransaction(pTrans);
 266     if (err.status == NdbError::TemporaryError){
 267       ERR(err);
 268       return NDBT_TEMPORARY;
 269     }
 270     ERR(err);
 271     return NDBT_FAILED;
 272   }
 273
 274
 275   Uint32  balanceFrom = balanceFromRec->u_32_value();
 276   //  ndbout << "balanceFrom: " << balanceFrom << endl;
 277
 278   if (((Int64)balanceFrom - amount) < 0){
 279     m_ndb.closeTransaction(pTrans);
 280     //ndbout << "Not enough funds" << endl;
 281     return NOT_ENOUGH_FUNDS;
 282   }
 283
 284   Uint32 fromAccountType = fromAccountTypeRec->u_32_value();
 285
 286   Uint32  balanceTo = balanceToRec->u_32_value();
 287   //  ndbout << "balanceTo: " << balanceTo << endl;
 288   Uint32 toAccountType = toAccountTypeRec->u_32_value();
 289
 290   /**
 291    * Update balance on from account
 292    */
 293   NdbOperation* pOp2 = pTrans->getNdbOperation("ACCOUNT");
 294   if (pOp2 == NULL) {
 295     ERR(pTrans->getNdbError());
 296     m_ndb.closeTransaction(pTrans);
 297     return NDBT_FAILED;
 298   }
 299
 300   check = pOp2->updateTuple();
 301   if( check == -1 ) {
 302     ERR(pTrans->getNdbError());
 303     m_ndb.closeTransaction(pTrans);
 304     return NDBT_FAILED;
 305   }
 306
 307   check = pOp2->equal("ACCOUNT_ID", fromAccountId);
 308   if( check == -1 ) {
 309     ERR(pTrans->getNdbError());
 310     m_ndb.closeTransaction(pTrans);
 311     return NDBT_FAILED;
 312   }
 313
 314   check = pOp2->setValue("BALANCE", balanceFrom - amount);
 315   if( check == -1 ) {
 316     ERR(pTrans->getNdbError());
 317     m_ndb.closeTransaction(pTrans);
 318     return NDBT_FAILED;
 319   }
 320
 321   /**
 322    * Update balance on to account
 323    */
 324   NdbOperation* pOp3 = pTrans->getNdbOperation("ACCOUNT");
 325   if (pOp3 == NULL) {
 326     ERR(pTrans->getNdbError());
 327     m_ndb.closeTransaction(pTrans);
 328     return NDBT_FAILED;
 329   }
 330
 331   check = pOp3->updateTuple();
 332   if( check == -1 ) {
 333     ERR(pTrans->getNdbError());
 334     m_ndb.closeTransaction(pTrans);
 335     return NDBT_FAILED;
 336   }
 337
 338   check = pOp3->equal("ACCOUNT_ID", toAccountId);
 339   if( check == -1 ) {
 340     ERR(pTrans->getNdbError());
 341     m_ndb.closeTransaction(pTrans);
 342     return NDBT_FAILED;
 343   }
 344
 345   check = pOp3->setValue("BALANCE", balanceTo + amount);
 346   if( check == -1 ) {
 347     ERR(pTrans->getNdbError());
 348     m_ndb.closeTransaction(pTrans);
 349     return NDBT_FAILED;
 350   }
 351
 352   /**
 353    * Insert withdrawal transaction
 354    */
 355   NdbOperation* pOp4 = pTrans->getNdbOperation("TRANSACTION");
 356   if (pOp4 == NULL) {
 357     ERR(pTrans->getNdbError());
 358     m_ndb.closeTransaction(pTrans);
 359     return NDBT_FAILED;
 360   }
 361
 362   check = pOp4->insertTuple();
 363   if( check == -1 ) {
 364     ERR(pTrans->getNdbError());
 365     m_ndb.closeTransaction(pTrans);
 366     return NDBT_FAILED;
 367   }
 368
 369   check = pOp4->equal("TRANSACTION_ID", transId);
 370   if( check == -1 ) {
 371     ERR(pTrans->getNdbError());
 372     m_ndb.closeTransaction(pTrans);
 373     return NDBT_FAILED;
 374   }
 375
 376   check = pOp4->equal("ACCOUNT", fromAccountId);
 377   if( check == -1 ) {
 378     ERR(pTrans->getNdbError());
 379     m_ndb.closeTransaction(pTrans);
 380     return NDBT_FAILED;
 381   }
 382
 383   check = pOp4->setValue("ACCOUNT_TYPE", fromAccountType);
 384   if( check == -1 ) {
 385     ERR(pTrans->getNdbError());
 386     m_ndb.closeTransaction(pTrans);
 387     return NDBT_FAILED;
 388   }
 389
 390   check = pOp4->setValue("OTHER_ACCOUNT", toAccountId);
 391   if( check == -1 ) {
 392     ERR(pTrans->getNdbError());
 393     m_ndb.closeTransaction(pTrans);
 394     return NDBT_FAILED;
 395   }
 396
 397   check = pOp4->setValue("TRANSACTION_TYPE", WithDrawal);
 398   if( check == -1 ) {
 399     ERR(pTrans->getNdbError());
 400     m_ndb.closeTransaction(pTrans);
 401     return NDBT_FAILED;
 402   }
 403
 404   check = pOp4->setValue("TIME", currTime);
 405   if( check == -1 ) {
 406     ERR(pTrans->getNdbError());
 407     m_ndb.closeTransaction(pTrans);
 408     return NDBT_FAILED;
 409   }
 410
 411   check = pOp4->setValue("AMOUNT", amount);
 412   if( check == -1 ) {
 413     ERR(pTrans->getNdbError());
 414     m_ndb.closeTransaction(pTrans);
 415     return NDBT_FAILED;
 416   }
 417
 418   /**
 419    * Insert deposit transaction
 420    */
 421   NdbOperation* pOp5 = pTrans->getNdbOperation("TRANSACTION");
 422   if (pOp5 == NULL) {
 423     ERR(pTrans->getNdbError());
 424     m_ndb.closeTransaction(pTrans);
 425     return NDBT_FAILED;
 426   }
 427
 428   check = pOp5->insertTuple();
 429   if( check == -1 ) {
 430     ERR(pTrans->getNdbError());
 431     m_ndb.closeTransaction(pTrans);
 432     return NDBT_FAILED;
 433   }
 434
 435   check = pOp5->equal("TRANSACTION_ID", transId);
 436   if( check == -1 ) {
 437     ERR(pTrans->getNdbError());
 438     m_ndb.closeTransaction(pTrans);
 439     return NDBT_FAILED;
 440   }
 441
 442   check = pOp5->equal("ACCOUNT", toAccountId);
 443   if( check == -1 ) {
 444     ERR(pTrans->getNdbError());
 445     m_ndb.closeTransaction(pTrans);
 446     return NDBT_FAILED;
 447   }
 448
 449   check = pOp5->setValue("ACCOUNT_TYPE", toAccountType);
 450   if( check == -1 ) {
 451     ERR(pTrans->getNdbError());
 452     m_ndb.closeTransaction(pTrans);
 453     return NDBT_FAILED;
 454   }
 455
 456   check = pOp5->setValue("OTHER_ACCOUNT", fromAccountId);
 457   if( check == -1 ) {
 458     ERR(pTrans->getNdbError());
 459     m_ndb.closeTransaction(pTrans);
 460     return NDBT_FAILED;
 461   }
 462
 463   check = pOp5->setValue("TRANSACTION_TYPE", Deposit);
 464   if( check == -1 ) {
 465     ERR(pTrans->getNdbError());
 466     m_ndb.closeTransaction(pTrans);
 467     return NDBT_FAILED;
 468   }
 469
 470   check = pOp5->setValue("TIME", currTime);
 471   if( check == -1 ) {
 472     ERR(pTrans->getNdbError());
 473     m_ndb.closeTransaction(pTrans);
 474     return NDBT_FAILED;
 475   }
 476
 477   check = pOp5->setValue("AMOUNT", amount);
 478   if( check == -1 ) {
 479     ERR(pTrans->getNdbError());
 480     m_ndb.closeTransaction(pTrans);
 481     return NDBT_FAILED;
 482   }
 483
 484   check = pTrans->execute(Commit);
 485   if( check == -1 ) {
 486     const NdbError err = pTrans->getNdbError();
 487     m_ndb.closeTransaction(pTrans);
 488     if (err.status == NdbError::TemporaryError){
 489       ERR(err);
 490       return NDBT_TEMPORARY;
 491     }
 492     ERR(err);
 493     return NDBT_FAILED;
 494   }
 495
 496   m_ndb.closeTransaction(pTrans);
 497   return NDBT_OK;
 498 }
 499
 500
 501
 502
 503 int Bank::performMakeGLs(int yield){
 504   int result;
 505
 506   int counter, maxCounter;
 507   int yieldCounter = 0;
 508
 509   while (1){
 510     // Counters to keep tracck of how many
 511     // GLs should be made before performing a validation
 512     counter = 0;
 513     maxCounter = 50 + myRandom48(100);
 514
 515     /**
 516      * Validate GLs and Transactions for previous days
 517      *
 518      */
 519     result = performValidateGLs();
 520     if (result != NDBT_OK){
 521       if (result == VERIFICATION_FAILED){
 522         g_err << "performValidateGLs verification failed" << endl;
 523         return NDBT_FAILED;
 524       }
 525       g_info << "performValidateGLs failed" << endl;
 526       return NDBT_FAILED;
 527       continue;
 528     }
 529
 530     result = performValidatePurged();
 531     if (result != NDBT_OK){
 532       if (result == VERIFICATION_FAILED){
 533         g_err << "performValidatePurged verification failed" << endl;
 534         return NDBT_FAILED;
 535       }
 536       g_info << "performValidatePurged failed" << endl;
 537       return NDBT_FAILED;
 538     }
 539
 540     while (1){
 541
 542       yieldCounter++;
 543       if (yield != 0 && yieldCounter >= yield)
 544         return NDBT_OK;
 545
 546       /**
 547        * Find last GL time.
 548        * ( GL record with highest time value)
 549        */
 550       Uint64 lastGLTime;
 551       if (findLastGL(lastGLTime) != NDBT_OK){
 552         g_info << "findLastGL failed" << endl;
 553         // Break out of inner while loop
 554         break;
 555       }
 556
 557       lastGLTime++;
 558
 559       /**
 560        * If last GL time + 1 is smaller than current time
 561        * perform a GL for that time
 562        */
 563       Uint64 currTime;
 564       if (getCurrTime(currTime) != NDBT_OK){
 565         g_info << "getCurrTime failed" << endl;
 566         // Break out of inner while loop
 567         break;
 568       }
 569       if (lastGLTime < currTime){
 570         counter++;
 571         if (performMakeGL(lastGLTime) != NDBT_OK){
 572           g_info << "performMakeGL failed" << endl;
 573         // Break out of inner while loop
 574           break;
 575         }
 576
 577         if (counter > maxCounter){
 578           // Break out of inner while loop and
 579           // validatePreviousGLs
 580           g_info << "counter("<<counter<<") > maxCounter("<<maxCounter<<")" << endl;
 581           break;
 582         }
 583
 584       } else {
 585         ;//ndbout << "It's not time to make GL yet" << endl;
 586
 587         // ndbout << "Sleeping 1 second" << endl;
 588         NdbSleep_SecSleep(1);
 589
 590       }
 591
 592       Uint32 age = 3;
 593       if (purgeOldGLTransactions(currTime, age) != NDBT_OK){
 594         g_info << "purgeOldGLTransactions failed" << endl;
 595         // Break out of inner while loop
 596         break;
 597       }
 598
 599     }
 600   }
 601
 602   return NDBT_FAILED;
 603
 604 }
 605
 606 int Bank::performValidateAllGLs(){
 607   int result;
 608
 609   while (1){
 610
 611     /**
 612      * Validate GLs and Transactions for previous days
 613      * Set age so that ALL GL's are validated
 614      */
 615     int age = 100000;
 616     result = performValidateGLs(age);
 617     if (result != NDBT_OK){
 618       if (result == VERIFICATION_FAILED){
 619         g_err << "performValidateGLs verification failed" << endl;
 620         return NDBT_FAILED;
 621       }
 622       g_err << "performValidateGLs failed" << endl;
 623       return NDBT_FAILED;
 624     }
 625
 626     /**
 627      *
 628      *
 629      */
 630     result = performValidatePurged();
 631     if (result != NDBT_OK){
 632       if (result == VERIFICATION_FAILED){
 633         g_err << "performValidatePurged verification failed" << endl;
 634         return NDBT_FAILED;
 635       }
 636       g_err << "performValidatePurged failed" << endl;
 637       return NDBT_FAILED;
 638     }
 639     return NDBT_OK;
 640   }
 641
 642   return NDBT_FAILED;
 643
 644 }
 645
 646 int Bank::findLastGL(Uint64 &lastTime){
 647
 648  int check;
 649   /**
 650    * SELECT MAX(time) FROM GL
 651    */
 652   NdbConnection* pScanTrans = m_ndb.startTransaction();
 653   if (pScanTrans == NULL) {
 654     ERR(m_ndb.getNdbError());
 655     return NDBT_FAILED;
 656   }
 657
 658   NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("GL");
 659   if (pOp == NULL) {
 660     ERR(pScanTrans->getNdbError());
 661     m_ndb.closeTransaction(pScanTrans);
 662     return NDBT_FAILED;
 663   }
 664
 665   if( pOp->readTuples() ) {
 666     ERR(pScanTrans->getNdbError());
 667     m_ndb.closeTransaction(pScanTrans);
 668     return NDBT_FAILED;
 669   }
 670
 671   check = pOp->interpret_exit_ok();
 672   if( check == -1 ) {
 673     ERR(pScanTrans->getNdbError());
 674     m_ndb.closeTransaction(pScanTrans);
 675     return NDBT_FAILED;
 676   }
 677
 678   NdbRecAttr* timeRec = pOp->getValue("TIME");
 679   if( timeRec ==NULL ) {
 680     ERR(pScanTrans->getNdbError());
 681     m_ndb.closeTransaction(pScanTrans);
 682     return NDBT_FAILED;
 683   }
 684
 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 = pOp->nextResult();
 695   lastTime = 0;
 696
 697   while(eof == 0){
 698     rows++;
 699     Uint64 t = timeRec->u_32_value();
 700
 701     if (t > lastTime)
 702       lastTime = t;
 703
 704     eof = pOp->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 }
 716
 717
 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 }
 748
 749 int Bank::performMakeGLForAccountType(NdbConnection* pTrans,
 750                                       Uint64 glTime,
 751                                       Uint32 accountTypeId){
 752   int check;
 753
 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;
 761
 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   }
 783
 784   check = pOp->equal("ACCOUNT_TYPE", accountTypeId);
 785   if( check == -1 ) {
 786     ERR(pTrans->getNdbError());
 787     return NDBT_FAILED;
 788   }
 789
 790   check = pOp->setValue("BALANCE", balance);
 791   if( check == -1 ) {
 792     ERR(pTrans->getNdbError());
 793     return NDBT_FAILED;
 794   }
 795
 796   check = pOp->setValue("DEPOSIT_COUNT", depositCount);
 797   if( check == -1 ) {
 798     ERR(pTrans->getNdbError());
 799     return NDBT_FAILED;
 800   }
 801
 802   check = pOp->setValue("DEPOSIT_SUM", depositSum);
 803   if( check == -1 ) {
 804     ERR(pTrans->getNdbError());
 805     return NDBT_FAILED;
 806   }
 807
 808   check = pOp->setValue("WITHDRAWAL_COUNT", withdrawalCount);
 809   if( check == -1 ) {
 810     ERR(pTrans->getNdbError());
 811     return NDBT_FAILED;
 812   }
 813
 814   check = pOp->setValue("WITHDRAWAL_SUM", withdrawalSum);
 815   if( check == -1 ) {
 816     ERR(pTrans->getNdbError());
 817     return NDBT_FAILED;
 818   }
 819
 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   }
 831
 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   }
 850
 851   check = pOp2->equal("ACCOUNT_TYPE", accountTypeId);
 852   if( check == -1 ) {
 853     ERR(pTrans->getNdbError());
 854     return NDBT_FAILED;
 855   }
 856
 857   NdbRecAttr* oldBalanceRec = pOp2->getValue("BALANCE");
 858   if( oldBalanceRec == NULL ) {
 859     ERR(pTrans->getNdbError());
 860     return NDBT_FAILED;
 861   }
 862
 863   check = pTrans->execute(NoCommit);
 864   if( check == -1 ) {
 865     ERR(pOp2->getNdbError());
 866     return NDBT_FAILED;
 867   }
 868
 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
 895
 896
 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   }
 914
 915   check = pOp3->equal("ACCOUNT_TYPE", accountTypeId);
 916   if( check == -1 ) {
 917     ERR(pTrans->getNdbError());
 918     return NDBT_FAILED;
 919   }
 920
 921   check = pOp3->setValue("BALANCE", balance);
 922   if( check == -1 ) {
 923     ERR(pTrans->getNdbError());
 924     return NDBT_FAILED;
 925   }
 926
 927   check = pOp3->setValue("DEPOSIT_COUNT", depositCount);
 928   if( check == -1 ) {
 929     ERR(pTrans->getNdbError());
 930     return NDBT_FAILED;
 931   }
 932
 933   check = pOp3->setValue("DEPOSIT_SUM", depositSum);
 934   if( check == -1 ) {
 935     ERR(pTrans->getNdbError());
 936     return NDBT_FAILED;
 937   }
 938
 939   check = pOp3->setValue("WITHDRAWAL_COUNT", withdrawalCount);
 940   if( check == -1 ) {
 941     ERR(pTrans->getNdbError());
 942     return NDBT_FAILED;
 943   }
 944
 945   check = pOp3->setValue("WITHDRAWAL_SUM", withdrawalSum);
 946   if( check == -1 ) {
 947     ERR(pTrans->getNdbError());
 948     return NDBT_FAILED;
 949   }
 950
 951   check = pOp3->setValue("PURGED", purged);
 952   if( check == -1 ) {
 953     ERR(pTrans->getNdbError());
 954     return NDBT_FAILED;
 955   }
 956
 957   // Execute transaction
 958   check = pTrans->execute(NoCommit);
 959   if( check == -1 ) {
 960     ERR(pTrans->getNdbError());
 961     return NDBT_FAILED;
 962   }
 963
 964   return NDBT_OK;
 965 }
 966
 967
 968
 969
 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;
 980
 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   }
 995
 996   if( pOp->readTuplesExclusive()) {
 997     ERR(pScanTrans->getNdbError());
 998     m_ndb.closeTransaction(pScanTrans);
 999     return NDBT_FAILED;
1000   }
1001
1002   check = pOp->interpret_exit_ok();
1003   if( check == -1 ) {
1004     ERR(pScanTrans->getNdbError());
1005     m_ndb.closeTransaction(pScanTrans);
1006     return NDBT_FAILED;
1007   }
1008
1009   NdbRecAttr* accountTypeRec = pOp->getValue("ACCOUNT_TYPE");
1010   if( accountTypeRec ==NULL ) {
1011     ERR(pScanTrans->getNdbError());
1012     m_ndb.closeTransaction(pScanTrans);
1013     return NDBT_FAILED;
1014   }
1015
1016   NdbRecAttr* timeRec = pOp->getValue("TIME");
1017   if( timeRec ==NULL ) {
1018     ERR(pScanTrans->getNdbError());
1019     m_ndb.closeTransaction(pScanTrans);
1020     return NDBT_FAILED;
1021   }
1022
1023   NdbRecAttr* transTypeRec = pOp->getValue("TRANSACTION_TYPE");
1024   if( transTypeRec ==NULL ) {
1025     ERR(pScanTrans->getNdbError());
1026     m_ndb.closeTransaction(pScanTrans);
1027     return NDBT_FAILED;
1028   }
1029
1030   NdbRecAttr* amountRec = pOp->getValue("AMOUNT");
1031   if( amountRec ==NULL ) {
1032     ERR(pScanTrans->getNdbError());
1033     m_ndb.closeTransaction(pScanTrans);
1034     return NDBT_FAILED;
1035   }
1036
1037   check = pScanTrans->execute(NoCommit);
1038   if( check == -1 ) {
1039     ERR(pScanTrans->getNdbError());
1040     m_ndb.closeTransaction(pScanTrans);
1041     return NDBT_FAILED;
1042   }
1043
1044   int eof;
1045   int rows = 0;
1046   int rowsFound = 0;
1047   eof = pOp->nextResult();
1048
1049   while(eof == 0){
1050     rows++;
1051     Uint32 a = accountTypeRec->u_32_value();
1052     Uint64 t = timeRec->u_64_value();
1053
1054     if (a == accountType && t == glTime){
1055       rowsFound++;
1056       // One record found
1057       int transType = transTypeRec->u_32_value();
1058       int amount = amountRec->u_32_value();
1059       if (transType == WithDrawal){
1060         withdrawalCount++;
1061         withdrawalSum += amount;
1062         balance -= amount;
1063       } else {
1064         assert(transType == Deposit);
1065         depositCount++;
1066         depositSum += amount;
1067         balance += amount;
1068       }
1069     }
1070
1071     eof = pOp->nextResult();
1072
1073     if ((rows % 100) == 0){
1074       // "refresh" ownner transaction every 100th row
1075       if (pTrans->refresh() == -1) {
1076         ERR(pTrans->getNdbError());
1077         return NDBT_FAILED;
1078       }
1079     }
1080
1081   }
1082   if (eof == -1) {
1083     ERR(pScanTrans->getNdbError());
1084     m_ndb.closeTransaction(pScanTrans);
1085     return NDBT_FAILED;
1086   }
1087
1088   m_ndb.closeTransaction(pScanTrans);
1089   //  ndbout << rows << " TRANSACTIONS have been read" << endl;
1090   transactionsCount = rowsFound;
1091
1092   return NDBT_OK;
1093
1094 }
1095
1096  int Bank::performValidateGLs(Uint64 age){
1097
1098   Uint64 currTime;
1099   if (getCurrTime(currTime) != NDBT_OK){
1100     return NDBT_FAILED;
1101   }
1102   Uint64 glTime = currTime - 1;
1103   while((glTime > 0) && ((glTime + age) >= currTime)){
1104
1105     int result = performValidateGL(glTime);
1106     if (result != NDBT_OK){
1107       g_err << "performValidateGL failed" << endl;
1108       return result;
1109     }
1110
1111     glTime--;
1112   }
1113
1114   return NDBT_OK;
1115  }
1116
1117 int Bank::performValidateGL(Uint64 glTime){
1118
1119    ndbout << "performValidateGL: " << glTime << endl;
1120    /**
1121     * Rules:
1122     * - There should be zero or NoAccountTypes GL records for each glTime
1123     * - If purged == 0, then the TRANSACTION table should be checked
1124     *   to see that there are:
1125     *   + DEPOSIT_COUNT deposit transactions with account_type == ACCOUNT_TYPE
1126     *     and TIME == glTime. The sum of these transactions should be
1127     *     DEPOSIT_SUM
1128     *   + WITHDRAWAL_COUNT withdrawal transactions with account_type ==
1129     *     ACCOUNT_TYPE and TIME == glTime. The sum of these transactions
1130     *     should be WITHDRAWAL_SUM
1131     *   + BALANCE should be equal to the sum of all transactions plus
1132     *     the balance of the previous GL record
1133     * - If purged == 1 then there should be NO transactions with TIME == glTime
1134     *   and ACCOUNT_TYPE == account_type
1135     *
1136     */
1137
1138    int check;
1139    /**
1140     * SELECT * FROM GL WHERE account_type = @accountType and time = @time
1141     */
1142    NdbConnection* pScanTrans = m_ndb.startTransaction();
1143    if (pScanTrans == NULL) {
1144      ERR(m_ndb.getNdbError());
1145      return NDBT_FAILED;
1146    }
1147
1148    NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("GL");
1149    if (pOp == NULL) {
1150      ERR(pScanTrans->getNdbError());
1151      m_ndb.closeTransaction(pScanTrans);
1152      return NDBT_FAILED;
1153    }
1154
1155    if( pOp->readTuples() ) {
1156      ERR(pScanTrans->getNdbError());
1157      m_ndb.closeTransaction(pScanTrans);
1158      return NDBT_FAILED;
1159    }
1160
1161    check = pOp->interpret_exit_ok();
1162    if( check == -1 ) {
1163      ERR(pScanTrans->getNdbError());
1164      m_ndb.closeTransaction(pScanTrans);
1165      return NDBT_FAILED;
1166    }
1167
1168    NdbRecAttr* accountTypeRec = pOp->getValue("ACCOUNT_TYPE");
1169    if( accountTypeRec ==NULL ) {
1170      ERR(pScanTrans->getNdbError());
1171      m_ndb.closeTransaction(pScanTrans);
1172      return NDBT_FAILED;
1173    }
1174
1175   NdbRecAttr* timeRec = pOp->getValue("TIME");
1176   if( timeRec ==NULL ) {
1177     ERR(pScanTrans->getNdbError());
1178     m_ndb.closeTransaction(pScanTrans);
1179     return NDBT_FAILED;
1180   }
1181
1182   NdbRecAttr* purgedRec = pOp->getValue("PURGED");
1183   if( purgedRec ==NULL ) {
1184     ERR(pScanTrans->getNdbError());
1185     m_ndb.closeTransaction(pScanTrans);
1186     return NDBT_FAILED;
1187   }
1188
1189   NdbRecAttr* balanceRec = pOp->getValue("BALANCE");
1190   if( balanceRec ==NULL ) {
1191     ERR(pScanTrans->getNdbError());
1192     m_ndb.closeTransaction(pScanTrans);
1193     return NDBT_FAILED;
1194   }
1195
1196   NdbRecAttr* depositSumRec = pOp->getValue("DEPOSIT_SUM");
1197   if( depositSumRec ==NULL ) {
1198     ERR(pScanTrans->getNdbError());
1199     m_ndb.closeTransaction(pScanTrans);
1200     return NDBT_FAILED;
1201   }
1202
1203   NdbRecAttr* depositCountRec = pOp->getValue("DEPOSIT_COUNT");
1204   if( depositCountRec ==NULL ) {
1205     ERR(pScanTrans->getNdbError());
1206     m_ndb.closeTransaction(pScanTrans);
1207     return NDBT_FAILED;
1208   }
1209
1210   NdbRecAttr* withdrawalSumRec = pOp->getValue("WITHDRAWAL_SUM");
1211   if( withdrawalSumRec ==NULL ) {
1212     ERR(pScanTrans->getNdbError());
1213     m_ndb.closeTransaction(pScanTrans);
1214     return NDBT_FAILED;
1215   }
1216   NdbRecAttr* withdrawalCountRec = pOp->getValue("WITHDRAWAL_COUNT");
1217   if( withdrawalCountRec ==NULL ) {
1218     ERR(pScanTrans->getNdbError());
1219     m_ndb.closeTransaction(pScanTrans);
1220     return NDBT_FAILED;
1221   }
1222
1223   check = pScanTrans->execute(NoCommit);
1224   if( check == -1 ) {
1225     ERR(pScanTrans->getNdbError());
1226     m_ndb.closeTransaction(pScanTrans);
1227     return NDBT_FAILED;
1228   }
1229
1230   int eof;
1231   int rows = 0;
1232   int countGlRecords = 0;
1233   int result = NDBT_OK;
1234   eof = pOp->nextResult();
1235
1236   while(eof == 0){
1237     rows++;
1238     Uint64 t = timeRec->u_64_value();
1239
1240     if (t == glTime){
1241       countGlRecords++;
1242       Uint32 a = accountTypeRec->u_32_value();
1243       Uint32 purged = purgedRec->u_32_value();
1244       Uint32 wsum = withdrawalSumRec->u_32_value();
1245       Uint32 wcount = withdrawalCountRec->u_32_value();
1246       Uint32 dsum = depositSumRec->u_32_value();
1247       Uint32 dcount = depositCountRec->u_32_value();
1248       Uint32 b = balanceRec->u_32_value();
1249
1250       Uint32 balance = 0;
1251       Uint32 withdrawalSum = 0;
1252       Uint32 withdrawalCount = 0;
1253       Uint32 depositSum = 0;
1254       Uint32 depositCount = 0;
1255       Uint32 countTransactions = 0;
1256       if (purged == 0){
1257         // If purged == 0, then the TRANSACTION table should be checked
1258         // to see that there are:
1259         // + DEPOSIT_COUNT deposit transactions with account_type == ACCOUNT_TYPE
1260         //   and TIME == glTime. The sum of these transactions should be
1261         //   DEPOSIT_SUM
1262         // + WITHDRAWAL_COUNT withdrawal transactions with account_type ==
1263         //   ACCOUNT_TYPE and TIME == glTime. The sum of these transactions
1264         //   should be WITHDRAWAL_SUM
1265         // + BALANCE should be equal to the sum of all transactions plus
1266         //   the balance of the previous GL record
1267         if (sumTransactionsForGL(t,
1268                                  a,
1269                                  balance,
1270                                  withdrawalCount,
1271                                  withdrawalSum,
1272                                  depositSum,
1273                                  depositCount,
1274                                  countTransactions,
1275                                  pScanTrans) != NDBT_OK){
1276           result = NDBT_FAILED;
1277         } else {
1278           Uint32 prevBalance = 0;
1279           if (getBalanceForGL(t-1, a, prevBalance) != NDBT_OK){
1280             result = NDBT_FAILED;
1281           } else
1282           if (((prevBalance + balance) != b) ||
1283               (wsum != withdrawalSum) ||
1284               (wcount != withdrawalCount) ||
1285               (dsum != depositSum) ||
1286               (dcount != depositCount)){
1287             g_err << "performValidateGL, sums and counts failed" << endl
1288                   << "balance   :   " << balance+prevBalance << "!="<<b<<endl
1289                   << "with sum  :   " << withdrawalSum << "!="<<wsum<<endl
1290                   << "with count:   " << withdrawalCount << "!="<<wcount<<endl
1291                   << "dep sum   :   " << depositSum << "!="<<dsum<<endl
1292                   << "dep count :   " << depositCount << "!="<<dcount<<endl;
1293             result = VERIFICATION_FAILED;
1294           }
1295             }
1296
1297       } else {
1298         assert(purged == 1);
1299         // If purged == 1 then there should be NO transactions with
1300         // TIME == glTime and ACCOUNT_TYPE == account_type
1301
1302         if (sumTransactionsForGL(t,
1303                                  a,
1304                                  balance,
1305                                  withdrawalCount,
1306                                  withdrawalSum,
1307                                  depositSum,
1308                                  depositCount,
1309                                  countTransactions,
1310                                  pScanTrans) != NDBT_OK){
1311           result = NDBT_FAILED;
1312         } else {
1313           if (countTransactions != 0){
1314             g_err << "performValidateGL, countTransactions("<<countTransactions<<") != 0" << endl;
1315             result = VERIFICATION_FAILED;
1316           }
1317         }
1318       }
1319
1320     }
1321     eof = pOp->nextResult();
1322   }
1323   if (eof == -1) {
1324     ERR(pScanTrans->getNdbError());
1325     m_ndb.closeTransaction(pScanTrans);
1326     return NDBT_FAILED;
1327   }
1328
1329   m_ndb.closeTransaction(pScanTrans);
1330
1331   // - There should be zero or NoAccountTypes GL records for each glTime
1332   if ((countGlRecords != 0) && (countGlRecords != getNumAccountTypes())){
1333     g_err << "performValidateGL: " << endl
1334            << "countGlRecords = " << countGlRecords << endl;
1335     result = VERIFICATION_FAILED;
1336   }
1337
1338   return result;
1339
1340
1341  }
1342
1343 int Bank::getBalanceForGL(const Uint64 glTime,
1344                           const Uint32 accountTypeId,
1345                           Uint32 &balance){
1346   int check;
1347
1348   NdbConnection* pTrans = m_ndb.startTransaction();
1349   if (pTrans == NULL) {
1350     ERR(m_ndb.getNdbError());
1351     return NDBT_FAILED;
1352   }
1353
1354   NdbOperation* pOp = pTrans->getNdbOperation("GL");
1355   if (pOp == NULL) {
1356     ERR(pTrans->getNdbError());
1357     return NDBT_FAILED;
1358   }
1359
1360   check = pOp->readTuple();
1361   if( check == -1 ) {
1362     ERR(pTrans->getNdbError());
1363     return NDBT_FAILED;
1364   }
1365
1366   check = pOp->equal("TIME", glTime);
1367   if( check == -1 ) {
1368     ERR(pTrans->getNdbError());
1369     return NDBT_FAILED;
1370   }
1371
1372   check = pOp->equal("ACCOUNT_TYPE", accountTypeId);
1373   if( check == -1 ) {
1374     ERR(pTrans->getNdbError());
1375     return NDBT_FAILED;
1376   }
1377
1378   NdbRecAttr* balanceRec = pOp->getValue("BALANCE");
1379   if( balanceRec == NULL ) {
1380     ERR(pTrans->getNdbError());
1381     return NDBT_FAILED;
1382   }
1383
1384   check = pTrans->execute(Commit);
1385   if( check == -1 ) {
1386     ERR(pTrans->getNdbError());
1387     return NDBT_FAILED;
1388   }
1389
1390   m_ndb.closeTransaction(pTrans);
1391
1392   balance = balanceRec->u_32_value();
1393
1394   return NDBT_OK;
1395 }
1396
1397
1398
1399 int Bank::getOldestPurgedGL(const Uint32 accountType,
1400                             Uint64 &oldest){
1401   int check;
1402   /**
1403    * SELECT MAX(time) FROM GL WHERE account_type = @accountType and purged=1
1404    */
1405   NdbConnection* pScanTrans = 0;
1406   do
1407   {
1408     pScanTrans = m_ndb.startTransaction();
1409     if (pScanTrans == NULL) {
1410       ERR(m_ndb.getNdbError());
1411       return NDBT_FAILED;
1412     }
1413
1414     NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("GL");
1415     if (pOp == NULL) {
1416       ERR(pScanTrans->getNdbError());
1417       m_ndb.closeTransaction(pScanTrans);
1418       return NDBT_FAILED;
1419     }
1420
1421     if( pOp->readTuples() ) {
1422       ERR(pScanTrans->getNdbError());
1423       m_ndb.closeTransaction(pScanTrans);
1424       return NDBT_FAILED;
1425     }
1426
1427     check = pOp->interpret_exit_ok();
1428     if( check == -1 ) {
1429       ERR(pScanTrans->getNdbError());
1430       m_ndb.closeTransaction(pScanTrans);
1431       return NDBT_FAILED;
1432     }
1433
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     }
1440
1441     NdbRecAttr* timeRec = pOp->getValue("TIME");
1442     if( timeRec ==NULL ) {
1443       ERR(pScanTrans->getNdbError());
1444       m_ndb.closeTransaction(pScanTrans);
1445       return NDBT_FAILED;
1446     }
1447
1448     NdbRecAttr* purgedRec = pOp->getValue("PURGED");
1449     if( purgedRec ==NULL ) {
1450       ERR(pScanTrans->getNdbError());
1451       m_ndb.closeTransaction(pScanTrans);
1452       return NDBT_FAILED;
1453     }
1454
1455     check = pScanTrans->execute(NoCommit);
1456     if( check == -1 ) {
1457       NdbError err = pScanTrans->getNdbError();
1458       ERR(err);
1459       m_ndb.closeTransaction(pScanTrans);
1460       if (err.status == NdbError::TemporaryError)
1461       {
1462         NdbSleep_MilliSleep(50);
1463         continue;
1464       }
1465       return NDBT_FAILED;
1466     }
1467
1468     int eof;
1469     int rows = 0;
1470     eof = pOp->nextResult();
1471     oldest = 0;
1472
1473     while(eof == 0){
1474       rows++;
1475       Uint32 a = accountTypeRec->u_32_value();
1476       Uint32 p = purgedRec->u_32_value();
1477
1478       if (a == accountType && p == 1){
1479         // One record found
1480         Uint64 t = timeRec->u_64_value();
1481         if (t > oldest)
1482           oldest = t;
1483       }
1484       eof = pOp->nextResult();
1485     }
1486     if (eof == -1)
1487     {
1488       NdbError err = pScanTrans->getNdbError();
1489       ERR(err);
1490       m_ndb.closeTransaction(pScanTrans);
1491
1492       if (err.status == NdbError::TemporaryError)
1493       {
1494         NdbSleep_MilliSleep(50);
1495         continue;
1496       }
1497       return NDBT_FAILED;
1498     }
1499     break;
1500   } while(true);
1501
1502   m_ndb.closeTransaction(pScanTrans);
1503
1504   return NDBT_OK;
1505 }
1506
1507 int Bank::getOldestNotPurgedGL(Uint64 &oldest,
1508                                Uint32 &accountTypeId,
1509                                bool &found){
1510   int check;
1511   /**
1512    * SELECT time, accountTypeId FROM GL
1513    * WHERE purged=0 order by time asc
1514    */
1515   NdbConnection* pScanTrans = m_ndb.startTransaction();
1516   if (pScanTrans == NULL) {
1517     ERR(m_ndb.getNdbError());
1518     return NDBT_FAILED;
1519   }
1520
1521   NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("GL");
1522   if (pOp == NULL) {
1523     ERR(pScanTrans->getNdbError());
1524     m_ndb.closeTransaction(pScanTrans);
1525     return NDBT_FAILED;
1526   }
1527
1528   if( pOp->readTuples() ) {
1529     ERR(pScanTrans->getNdbError());
1530     m_ndb.closeTransaction(pScanTrans);
1531     return NDBT_FAILED;
1532   }
1533
1534   check = pOp->interpret_exit_ok();
1535   if( check == -1 ) {
1536     ERR(pScanTrans->getNdbError());
1537     m_ndb.closeTransaction(pScanTrans);
1538     return NDBT_FAILED;
1539   }
1540
1541   NdbRecAttr* accountTypeRec = pOp->getValue("ACCOUNT_TYPE");
1542   if( accountTypeRec ==NULL ) {
1543     ERR(pScanTrans->getNdbError());
1544     m_ndb.closeTransaction(pScanTrans);
1545     return NDBT_FAILED;
1546   }
1547
1548   NdbRecAttr* timeRec = pOp->getValue("TIME");
1549   if( timeRec ==NULL ) {
1550     ERR(pScanTrans->getNdbError());
1551     m_ndb.closeTransaction(pScanTrans);
1552     return NDBT_FAILED;
1553   }
1554
1555   NdbRecAttr* purgedRec = pOp->getValue("PURGED");
1556   if( purgedRec ==NULL ) {
1557     ERR(pScanTrans->getNdbError());
1558     m_ndb.closeTransaction(pScanTrans);
1559     return NDBT_FAILED;
1560   }
1561
1562   check = pScanTrans->execute(NoCommit);
1563   if( check == -1 ) {
1564     ERR(pScanTrans->getNdbError());
1565     m_ndb.closeTransaction(pScanTrans);
1566     return NDBT_FAILED;
1567   }
1568
1569   int eof;
1570   int rows = 0;
1571   eof = pOp->nextResult();
1572   oldest = (Uint64)-1;
1573   found = false;
1574
1575   while(eof == 0){
1576     rows++;
1577     Uint32 p = purgedRec->u_32_value();
1578     if (p == 0){
1579       found = true;
1580       // One record found
1581       Uint32 a = accountTypeRec->u_32_value();
1582       Uint64 t = timeRec->u_64_value();
1583       if (t < oldest){
1584         oldest = t;
1585         accountTypeId = a;
1586       }
1587     }
1588     eof = pOp->nextResult();
1589   }
1590   if (eof == -1) {
1591     ERR(pScanTrans->getNdbError());
1592     m_ndb.closeTransaction(pScanTrans);
1593     return NDBT_FAILED;
1594   }
1595
1596   m_ndb.closeTransaction(pScanTrans);
1597
1598   return NDBT_OK;
1599 }
1600
1601
1602 int Bank::checkNoTransactionsOlderThan(const Uint32 accountType,
1603                                        const Uint64 oldest){
1604   /**
1605    * SELECT COUNT(transaction_id) FROM TRANSACTION
1606    * WHERE account_type = @accountType and time <= @oldest
1607    *
1608    */
1609
1610   int loop = 0;
1611   int found = 0;
1612   NdbConnection* pScanTrans = 0;
1613   do {
1614     int check;
1615     loop++;
1616     pScanTrans = m_ndb.startTransaction();
1617     if (pScanTrans == NULL) {
1618       ERR(m_ndb.getNdbError());
1619       return NDBT_FAILED;
1620     }
1621
1622     NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("TRANSACTION");
1623     if (pOp == NULL) {
1624       ERR(pScanTrans->getNdbError());
1625       m_ndb.closeTransaction(pScanTrans);
1626       return NDBT_FAILED;
1627     }
1628
1629     if( pOp->readTuples() ) {
1630       ERR(pScanTrans->getNdbError());
1631       m_ndb.closeTransaction(pScanTrans);
1632       return NDBT_FAILED;
1633     }
1634
1635     check = pOp->interpret_exit_ok();
1636     if( check == -1 ) {
1637       ERR(pScanTrans->getNdbError());
1638       m_ndb.closeTransaction(pScanTrans);
1639       return NDBT_FAILED;
1640     }
1641
1642     NdbRecAttr* accountTypeRec = pOp->getValue("ACCOUNT_TYPE");
1643     if( accountTypeRec ==NULL ) {
1644       ERR(pScanTrans->getNdbError());
1645       m_ndb.closeTransaction(pScanTrans);
1646       return NDBT_FAILED;
1647     }
1648
1649     NdbRecAttr* timeRec = pOp->getValue("TIME");
1650     if( timeRec ==NULL ) {
1651       ERR(pScanTrans->getNdbError());
1652       m_ndb.closeTransaction(pScanTrans);
1653       return NDBT_FAILED;
1654     }
1655
1656     NdbRecAttr* transactionIdRec = pOp->getValue("TRANSACTION_ID");
1657     if( transactionIdRec ==NULL ) {
1658       ERR(pScanTrans->getNdbError());
1659       m_ndb.closeTransaction(pScanTrans);
1660       return NDBT_FAILED;
1661     }
1662
1663     check = pScanTrans->execute(NoCommit);
1664     if( check == -1 ) {
1665       NdbError err = pScanTrans->getNdbError();
1666       ERR(err);
1667       m_ndb.closeTransaction(pScanTrans);
1668
1669       if (err.status == NdbError::TemporaryError)
1670       {
1671         NdbSleep_MilliSleep(50);
1672         continue;
1673       }
1674       return NDBT_FAILED;
1675     }
1676
1677     int eof;
1678     int rows = 0;
1679     found = 0;
1680     eof = pOp->nextResult();
1681
1682     while(eof == 0){
1683       rows++;
1684       Uint32 a = accountTypeRec->u_32_value();
1685       Uint32 t = timeRec->u_32_value();
1686
1687       if (a == accountType && t <= oldest){
1688         // One record found
1689         Uint64 ti = transactionIdRec->u_64_value();
1690         g_err << "checkNoTransactionsOlderThan found one record" << endl
1691               << "  t = " << t << endl
1692               << "  a = " << a << endl
1693               << "  ti = " << ti << endl;
1694         found++;
1695       }
1696       eof = pOp->nextResult();
1697     }
1698     if (eof == -1) {
1699       NdbError err = pScanTrans->getNdbError();
1700       ERR(err);
1701       m_ndb.closeTransaction(pScanTrans);
1702
1703       if (err.status == NdbError::TemporaryError)
1704       {
1705         NdbSleep_MilliSleep(50);
1706         continue;
1707       }
1708
1709       return NDBT_FAILED;
1710     }
1711
1712     break;
1713   } while(true);
1714
1715   m_ndb.closeTransaction(pScanTrans);
1716
1717   if (found == 0)
1718     return NDBT_OK;
1719   else
1720     return VERIFICATION_FAILED;
1721 }
1722
1723
1724  int Bank::performValidatePurged(){
1725    /**
1726     * Make sure there are no TRANSACTIONS older than the oldest
1727     * purged GL record
1728     *
1729     */
1730
1731    for (int i = 0; i < getNumAccountTypes(); i++){
1732      ndbout << "performValidatePurged: " << i << endl;
1733      Uint64 oldestGlTime;
1734      if (getOldestPurgedGL(i, oldestGlTime) != NDBT_OK){
1735        g_err << "getOldestPurgedGL failed" << endl;
1736        return NDBT_FAILED;
1737      }
1738      int result = checkNoTransactionsOlderThan(i, oldestGlTime);
1739      if (result != NDBT_OK){
1740        g_err << "checkNoTransactionsOlderThan failed" << endl;
1741        return result;
1742      }
1743
1744    }
1745
1746    return NDBT_OK;
1747  }
1748
1749  int Bank::purgeOldGLTransactions(Uint64 currTime, Uint32 age){
1750    /**
1751     * For each GL record that are older than age and have purged == 0
1752     *  - delete all TRANSACTIONS belonging to the GL and set purged = 1
1753     *
1754     *
1755     */
1756    bool found;
1757    int count = 0;
1758
1759    while(1){
1760      count++;
1761      if (count > 100)
1762        return NDBT_OK;
1763
1764      // Search for the oldest GL record with purged == 0
1765      Uint64 oldestGlTime;
1766      Uint32 accountTypeId;
1767      if (getOldestNotPurgedGL(oldestGlTime, accountTypeId, found) != NDBT_OK){
1768        g_err << "getOldestNotPurgedGL failed" << endl;
1769        return NDBT_FAILED;
1770      }
1771
1772
1773      if (found == false){
1774        // ndbout << "not found" << endl;
1775        return NDBT_OK;
1776      }
1777
1778
1779 //      ndbout << "purgeOldGLTransactions" << endl
1780 //                  << "  oldestGlTime = " << oldestGlTime << endl
1781 //                  << "  currTime = " << currTime << endl
1782 //          << "  age = " << age << endl;
1783      // Check if this GL is old enough to be purged
1784      if ((currTime < age) || (oldestGlTime > (currTime-age))){
1785        //       ndbout << "is not old enough" << endl;
1786        return NDBT_OK;
1787      }
1788
1789      if (purgeTransactions(oldestGlTime, accountTypeId) != NDBT_OK){
1790        g_err << "purgeTransactions failed" << endl;
1791        return NDBT_FAILED;
1792      }
1793    }
1794    g_err << "abnormal return" << endl;
1795    return NDBT_FAILED;
1796  }
1797
1798
1799 int Bank::purgeTransactions(const Uint64 glTime,
1800                             const Uint32 accountTypeId)
1801 {
1802   int check;
1803   g_info << "purgeTransactions: " << glTime << ", "<<accountTypeId<<endl;
1804   NdbConnection* pTrans = m_ndb.startTransaction();
1805   if (pTrans == NULL){
1806     ERR(m_ndb.getNdbError());
1807     return NDBT_FAILED;
1808   }
1809
1810   // Start by updating the GL record with purged = 1, use NoCommit
1811   NdbOperation* pOp = pTrans->getNdbOperation("GL");
1812   if (pOp == NULL) {
1813     ERR(pTrans->getNdbError());
1814     return NDBT_FAILED;
1815   }
1816
1817   check = pOp->updateTuple();
1818   if( check == -1 ) {
1819     ERR(pTrans->getNdbError());
1820     return NDBT_FAILED;
1821   }
1822
1823   check = pOp->equal("TIME", glTime);
1824   if( check == -1 ) {
1825     ERR(pTrans->getNdbError());
1826     return NDBT_FAILED;
1827   }
1828
1829   check = pOp->equal("ACCOUNT_TYPE", accountTypeId);
1830   if( check == -1 ) {
1831     ERR(pTrans->getNdbError());
1832     return NDBT_FAILED;
1833   }
1834
1835   Uint32 purged = 1;
1836   check = pOp->setValue("PURGED", purged);
1837   if( check == -1 ) {
1838     ERR(pTrans->getNdbError());
1839     return NDBT_FAILED;
1840   }
1841
1842   // Execute transaction
1843   check = pTrans->execute(NoCommit);
1844   if( check == -1 ) {
1845     ERR(pTrans->getNdbError());
1846     return NDBT_FAILED;
1847   }
1848
1849   // Find all transactions and take over them for delete
1850
1851   if(findTransactionsToPurge(glTime,
1852                             accountTypeId,
1853                             pTrans) != NDBT_OK){
1854     g_err << "findTransactionToPurge failed" << endl;
1855     m_ndb.closeTransaction(pTrans);
1856     return NDBT_FAILED;
1857   }
1858
1859
1860
1861   check = pTrans->execute(Commit);
1862   if( check == -1 ) {
1863     ERR(pTrans->getNdbError());
1864     return NDBT_FAILED;
1865   }
1866
1867   m_ndb.closeTransaction(pTrans);
1868   return NDBT_OK;
1869 }
1870
1871
1872 int Bank::findTransactionsToPurge(const Uint64 glTime,
1873                                   const Uint32 accountType,
1874                                   NdbConnection* pTrans){
1875   int check;
1876
1877   NdbConnection* pScanTrans = m_ndb.startTransaction();
1878   if (pScanTrans == NULL) {
1879     ERR(m_ndb.getNdbError());
1880     return NDBT_FAILED;
1881   }
1882
1883   NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("TRANSACTION");
1884   if (pOp == NULL) {
1885     ERR(pScanTrans->getNdbError());
1886     m_ndb.closeTransaction(pScanTrans);
1887     return NDBT_FAILED;
1888   }
1889
1890   if( pOp->readTuplesExclusive() ) {
1891     ERR(pScanTrans->getNdbError());
1892     m_ndb.closeTransaction(pScanTrans);
1893     return NDBT_FAILED;
1894   }
1895
1896   check = pOp->interpret_exit_ok();
1897   if( check == -1 ) {
1898     ERR(pScanTrans->getNdbError());
1899     m_ndb.closeTransaction(pScanTrans);
1900     return NDBT_FAILED;
1901   }
1902
1903   NdbRecAttr* timeRec = pOp->getValue("TIME");
1904   if( timeRec ==NULL ) {
1905     ERR(pScanTrans->getNdbError());
1906     m_ndb.closeTransaction(pScanTrans);
1907     return NDBT_FAILED;
1908   }
1909
1910   NdbRecAttr* accountTypeRec = pOp->getValue("ACCOUNT_TYPE");
1911   if( accountTypeRec ==NULL ) {
1912     ERR(pScanTrans->getNdbError());
1913     m_ndb.closeTransaction(pScanTrans);
1914     return NDBT_FAILED;
1915   }
1916
1917   check = pScanTrans->execute(NoCommit);
1918   if( check == -1 ) {
1919     ERR(pScanTrans->getNdbError());
1920     m_ndb.closeTransaction(pScanTrans);
1921     return NDBT_FAILED;
1922   }
1923
1924   int eof;
1925   int rows = 0;
1926   int rowsFound = 0;
1927   eof = pOp->nextResult();
1928
1929   while(eof == 0){
1930     rows++;
1931     Uint64 t = timeRec->u_64_value();
1932     Uint32 a = accountTypeRec->u_32_value();
1933
1934     if (a == accountType && t == glTime){
1935       rowsFound++;
1936       // One record found
1937       check = pOp->deleteCurrentTuple(pTrans);
1938       if (check == -1){
1939         ERR(m_ndb.getNdbError());
1940         m_ndb.closeTransaction(pScanTrans);
1941         return NDBT_FAILED;
1942       }
1943
1944       // Execute transaction
1945       check = pTrans->execute(NoCommit);
1946       if( check == -1 ) {
1947         ERR(pTrans->getNdbError());
1948         m_ndb.closeTransaction(pScanTrans);
1949         return NDBT_FAILED;
1950       }
1951     }
1952     eof = pOp->nextResult();
1953   }
1954   if (eof == -1) {
1955     ERR(pScanTrans->getNdbError());
1956     m_ndb.closeTransaction(pScanTrans);
1957     return NDBT_FAILED;
1958   }
1959
1960   m_ndb.closeTransaction(pScanTrans);
1961   //  ndbout << rowsFound << " TRANSACTIONS have been deleted" << endl;
1962
1963   return NDBT_OK;
1964
1965 }
1966
1967
1968 int Bank::performIncreaseTime(int maxSleepBetweenDays, int yield)
1969 {
1970   int yieldCounter = 0;
1971
1972   while(1){
1973
1974     Uint64 currTime;
1975     if (incCurrTime(currTime) != NDBT_OK)
1976       break;
1977
1978     g_info << "Current time is " << currTime << endl;
1979     if (maxSleepBetweenDays > 0){
1980       int val = myRandom48(maxSleepBetweenDays);
1981       NdbSleep_SecSleep(val);
1982     }
1983
1984     yieldCounter++;
1985     if (yield != 0 && yieldCounter >= yield)
1986       return NDBT_OK;
1987
1988   }
1989   return NDBT_FAILED;
1990 }
1991
1992 int Bank::readSystemValue(SystemValueId sysValId, Uint64 & value){
1993
1994   int check;
1995   NdbConnection* pTrans = 0;
1996   while (true)
1997   {
1998     pTrans = m_ndb.startTransaction();
1999     if (pTrans == NULL)
2000     {
2001       ERR(m_ndb.getNdbError());
2002       if(m_ndb.getNdbError().status == NdbError::TemporaryError)
2003       {
2004         NdbSleep_MilliSleep(50);
2005         continue;
2006       }
2007       return NDBT_FAILED;
2008     }
2009
2010     int result;
2011     if ((result= prepareReadSystemValueOp(pTrans, sysValId, value)) != NDBT_OK)
2012     {
2013       ERR(pTrans->getNdbError());
2014       m_ndb.closeTransaction(pTrans);
2015       return result;
2016     }
2017
2018     check = pTrans->execute(Commit);
2019     if( check == -1 ) {
2020       NdbError err = pTrans->getNdbError();
2021       m_ndb.closeTransaction(pTrans);
2022       ERR(err);
2023       if(err.status == NdbError::TemporaryError)
2024       {
2025         NdbSleep_MilliSleep(50);
2026         continue;
2027       }
2028       return NDBT_FAILED;
2029     }
2030
2031     break;
2032   }
2033
2034   m_ndb.closeTransaction(pTrans);
2035   return NDBT_OK;
2036
2037 }
2038
2039 int Bank::prepareReadSystemValueOp(NdbConnection* pTrans, SystemValueId sysValId, Uint64 & value){
2040
2041   int check;
2042
2043   NdbOperation* pOp = pTrans->getNdbOperation("SYSTEM_VALUES");
2044   if (pOp == NULL) {
2045     return NDBT_FAILED;
2046   }
2047
2048   check = pOp->readTuple();
2049   if( check == -1 ) {
2050     return NDBT_FAILED;
2051   }
2052
2053   check = pOp->equal("SYSTEM_VALUES_ID", sysValId);
2054   if( check == -1 ) {
2055     return NDBT_FAILED;
2056   }
2057
2058   NdbRecAttr* valueRec = pOp->getValue("VALUE", (char *)&value);
2059   if( valueRec == NULL ) {
2060     return NDBT_FAILED;
2061   }
2062
2063   return NDBT_OK;
2064 }
2065
2066 int Bank::writeSystemValue(SystemValueId sysValId, Uint64 value){
2067
2068   int check;
2069
2070   NdbConnection* pTrans = m_ndb.startTransaction();
2071   if (pTrans == NULL){
2072     ERR(m_ndb.getNdbError());
2073     return NDBT_FAILED;
2074   }
2075
2076   NdbOperation* pOp = pTrans->getNdbOperation("SYSTEM_VALUES");
2077   if (pOp == NULL) {
2078     ERR(pTrans->getNdbError());
2079     m_ndb.closeTransaction(pTrans);
2080     return NDBT_FAILED;
2081   }
2082
2083   check = pOp->insertTuple();
2084   if( check == -1 ) {
2085     ERR(pTrans->getNdbError());
2086     m_ndb.closeTransaction(pTrans);
2087     return NDBT_FAILED;
2088   }
2089
2090   check = pOp->equal("SYSTEM_VALUES_ID", sysValId);
2091   if( check == -1 ) {
2092     ERR(pTrans->getNdbError());
2093     m_ndb.closeTransaction(pTrans);
2094     return NDBT_FAILED;
2095   }
2096
2097   check = pOp->setValue("VALUE", value);
2098   if( check == -1 ) {
2099     ERR(pTrans->getNdbError());
2100     m_ndb.closeTransaction(pTrans);
2101     return NDBT_FAILED;
2102   }
2103
2104   check = pTrans->execute(Commit);
2105   if( check == -1 ) {
2106     ERR(pTrans->getNdbError());
2107     m_ndb.closeTransaction(pTrans);
2108     return NDBT_FAILED;
2109   }
2110
2111   m_ndb.closeTransaction(pTrans);
2112   return NDBT_OK;
2113
2114 }
2115
2116 int Bank::getNextTransactionId(Uint64 &value){
2117   return increaseSystemValue2(LastTransactionId, value);
2118 }
2119
2120 int Bank::incCurrTime(Uint64 &value){
2121   return increaseSystemValue(CurrentTime, value);
2122 }
2123
2124
2125 int Bank::increaseSystemValue(SystemValueId sysValId, Uint64 &value){
2126   /**
2127    * Increase value with one and return
2128    * updated value
2129    *
2130    */
2131
2132   DBUG_ENTER("Bank::increaseSystemValue");
2133
2134   int check;
2135
2136   NdbConnection* pTrans = m_ndb.startTransaction();
2137   if (pTrans == NULL){
2138     ERR(m_ndb.getNdbError());
2139     if (m_ndb.getNdbError().status == NdbError::TemporaryError)
2140       DBUG_RETURN(NDBT_TEMPORARY);
2141     DBUG_RETURN(NDBT_FAILED);
2142   }
2143
2144   NdbOperation* pOp = pTrans->getNdbOperation("SYSTEM_VALUES");
2145   if (pOp == NULL) {
2146     ERR(pTrans->getNdbError());
2147     m_ndb.closeTransaction(pTrans);
2148     DBUG_RETURN(NDBT_FAILED);
2149   }
2150
2151   check = pOp->readTupleExclusive();
2152   //  check = pOp->readTuple();
2153   if( check == -1 ) {
2154     ERR(pTrans->getNdbError());
2155     m_ndb.closeTransaction(pTrans);
2156     DBUG_RETURN(NDBT_FAILED);
2157   }
2158
2159   check = pOp->equal("SYSTEM_VALUES_ID", sysValId);
2160   if( check == -1 ) {
2161     ERR(pTrans->getNdbError());
2162     m_ndb.closeTransaction(pTrans);
2163     DBUG_RETURN(NDBT_FAILED);
2164   }
2165
2166   NdbRecAttr* valueRec = pOp->getValue("VALUE");
2167   if( valueRec ==NULL ) {
2168     ERR(pTrans->getNdbError());
2169     m_ndb.closeTransaction(pTrans);
2170     DBUG_RETURN(NDBT_FAILED);
2171   }
2172
2173   check = pTrans->execute(NoCommit);
2174   if( check == -1 ) {
2175     ERR(pTrans->getNdbError());
2176     if (pTrans->getNdbError().status == NdbError::TemporaryError)
2177     {
2178       m_ndb.closeTransaction(pTrans);
2179       DBUG_RETURN(NDBT_TEMPORARY);
2180     }
2181     m_ndb.closeTransaction(pTrans);
2182     DBUG_RETURN(NDBT_FAILED);
2183   }
2184
2185   value = valueRec->u_64_value();
2186   value++;
2187
2188   NdbOperation* pOp2 = pTrans->getNdbOperation("SYSTEM_VALUES");
2189   if (pOp2 == NULL) {
2190     ERR(pTrans->getNdbError());
2191     m_ndb.closeTransaction(pTrans);
2192     DBUG_RETURN(NDBT_FAILED);
2193   }
2194
2195   check = pOp2->updateTuple();
2196   if( check == -1 ) {
2197     ERR(pTrans->getNdbError());
2198     m_ndb.closeTransaction(pTrans);
2199     DBUG_RETURN(NDBT_FAILED);
2200   }
2201
2202   check = pOp2->equal("SYSTEM_VALUES_ID", sysValId);
2203   if( check == -1 ) {
2204     ERR(pTrans->getNdbError());
2205     m_ndb.closeTransaction(pTrans);
2206     DBUG_RETURN(NDBT_FAILED);
2207   }
2208
2209   check = pOp2->setValue("VALUE", value);
2210   if( check == -1 ) {
2211     ERR(pTrans->getNdbError());
2212     m_ndb.closeTransaction(pTrans);
2213     DBUG_RETURN(NDBT_FAILED);
2214   }
2215
2216   check = pTrans->execute(NoCommit);
2217   if( check == -1 ) {
2218     ERR(pTrans->getNdbError());
2219     m_ndb.closeTransaction(pTrans);
2220     DBUG_RETURN(NDBT_FAILED);
2221   }
2222
2223   NdbOperation* pOp3 = pTrans->getNdbOperation("SYSTEM_VALUES");
2224   if (pOp3 == NULL) {
2225     ERR(pTrans->getNdbError());
2226     m_ndb.closeTransaction(pTrans);
2227     DBUG_RETURN(NDBT_FAILED);
2228   }
2229
2230   check = pOp3->readTuple();
2231   if( check == -1 ) {
2232     ERR(pTrans->getNdbError());
2233     m_ndb.closeTransaction(pTrans);
2234     DBUG_RETURN(NDBT_FAILED);
2235   }
2236
2237   check = pOp3->equal("SYSTEM_VALUES_ID", sysValId);
2238   if( check == -1 ) {
2239     ERR(pTrans->getNdbError());
2240     m_ndb.closeTransaction(pTrans);
2241     DBUG_RETURN(NDBT_FAILED);
2242   }
2243
2244   // Read new value
2245   NdbRecAttr* valueNewRec = pOp3->getValue("VALUE");
2246   if( valueNewRec ==NULL ) {
2247     ERR(pTrans->getNdbError());
2248     m_ndb.closeTransaction(pTrans);
2249     DBUG_RETURN(NDBT_FAILED);
2250   }
2251
2252   check = pTrans->execute(Commit);
2253   if( check == -1 ) {
2254     ERR(pTrans->getNdbError());
2255     if (pTrans->getNdbError().status == NdbError::TemporaryError)
2256     {
2257       m_ndb.closeTransaction(pTrans);
2258       DBUG_RETURN(NDBT_TEMPORARY);
2259     }
2260     m_ndb.closeTransaction(pTrans);
2261     DBUG_RETURN(NDBT_FAILED);
2262   }
2263
2264   // Check that value updated equals the value we read after the update
2265   if (valueNewRec->u_64_value() != value){
2266
2267     printf("value actual=%lld\n", valueNewRec->u_64_value());
2268     printf("value expected=%lld actual=%lld\n", value, valueNewRec->u_64_value());
2269
2270     DBUG_PRINT("info", ("value expected=%ld actual=%ld", value, valueNewRec->u_64_value()));
2271     g_err << "getNextTransactionId: value was not updated" << endl;
2272     m_ndb.closeTransaction(pTrans);
2273     DBUG_RETURN(NDBT_FAILED);
2274   }
2275
2276   m_ndb.closeTransaction(pTrans);
2277
2278   DBUG_RETURN(0);
2279 }
2280
2281 int Bank::increaseSystemValue2(SystemValueId sysValId, Uint64 &value){
2282   /**
2283    * Increase value with one and return
2284    * updated value
2285    * A more optimized version using interpreted update!
2286    *
2287    */
2288
2289   int check;
2290
2291   NdbConnection* pTrans = m_ndb.startTransaction();
2292   if (pTrans == NULL){
2293     ERR(m_ndb.getNdbError());
2294     if(m_ndb.getNdbError().status == NdbError::TemporaryError)
2295       return NDBT_TEMPORARY;
2296     return NDBT_FAILED;
2297   }
2298
2299   NdbOperation* pOp = pTrans->getNdbOperation("SYSTEM_VALUES");
2300   if (pOp == NULL) {
2301     ERR(pTrans->getNdbError());
2302     m_ndb.closeTransaction(pTrans);
2303     return NDBT_FAILED;
2304   }
2305
2306   check = pOp->interpretedUpdateTuple();
2307   if( check == -1 ) {
2308     ERR(pTrans->getNdbError());
2309     m_ndb.closeTransaction(pTrans);
2310     return NDBT_FAILED;
2311   }
2312
2313   check = pOp->equal("SYSTEM_VALUES_ID", sysValId );
2314   if( check == -1 ) {
2315     ERR(pTrans->getNdbError());
2316     m_ndb.closeTransaction(pTrans);
2317     return NDBT_FAILED;
2318   }
2319
2320   Uint32 valToIncWith = 1;
2321   check = pOp->incValue("VALUE", valToIncWith);
2322   if( check == -1 ) {
2323     ERR(pTrans->getNdbError());
2324     m_ndb.closeTransaction(pTrans);
2325     return NDBT_FAILED;
2326   }
2327
2328   NdbRecAttr* valueRec = pOp->getValue("VALUE");
2329   if( valueRec == NULL ) {
2330     ERR(pTrans->getNdbError());
2331     m_ndb.closeTransaction(pTrans);
2332     return NDBT_FAILED;
2333   }
2334
2335   check = pTrans->execute(Commit);
2336   if( check == -1 ) {
2337     ERR(pTrans->getNdbError());
2338     if(pTrans->getNdbError().status == NdbError::TemporaryError)
2339     {
2340       m_ndb.closeTransaction(pTrans);
2341       return NDBT_TEMPORARY;
2342     }
2343     m_ndb.closeTransaction(pTrans);
2344     return NDBT_FAILED;
2345   }
2346
2347   value = valueRec->u_64_value();
2348
2349   m_ndb.closeTransaction(pTrans);
2350
2351   return 0;
2352
2353 }
2354
2355
2356
2357 int Bank::getCurrTime(Uint64 &time){
2358   return readSystemValue(CurrentTime, time);
2359 }
2360
2361 int Bank::prepareGetCurrTimeOp(NdbConnection *pTrans, Uint64 &time){
2362   return prepareReadSystemValueOp(pTrans, CurrentTime, time);
2363 }
2364
2365
2366 int Bank::performSumAccounts(int maxSleepBetweenSums, int yield){
2367
2368   int yieldCounter = 0;
2369
2370   while (1){
2371
2372     Uint32 sumAccounts = 0;
2373     Uint32 numAccounts = 0;
2374     if (getSumAccounts(sumAccounts, numAccounts) != NDBT_OK){
2375       g_err << "getSumAccounts FAILED" << endl;
2376     } else {
2377
2378       g_info << "num="<<numAccounts<<", sum=" << sumAccounts << endl;
2379
2380       if (sumAccounts != (10000000 + (10000*(numAccounts-1)))){
2381         g_err << "performSumAccounts  FAILED" << endl
2382               << "   sumAccounts="<<sumAccounts<<endl
2383               << "   expected   ="<<(10000000 + (10000*(numAccounts-1)))<<endl
2384               << "   numAccounts="<<numAccounts<<endl;
2385         return NDBT_FAILED;
2386       }
2387
2388       if (maxSleepBetweenSums > 0){
2389         int val = myRandom48(maxSleepBetweenSums);
2390         NdbSleep_MilliSleep(val);
2391       }
2392     }
2393
2394     yieldCounter++;
2395     if (yield != 0 && yieldCounter >= yield)
2396       return NDBT_OK;
2397   }
2398   return NDBT_FAILED;
2399 }
2400
2401
2402 int Bank::getSumAccounts(Uint32 &sumAccounts,
2403                          Uint32 &numAccounts){
2404
2405   // SELECT SUM(balance) FROM ACCOUNT
2406
2407   int check;
2408   NdbConnection* pScanTrans = m_ndb.startTransaction();
2409   if (pScanTrans == NULL) {
2410     ERR(m_ndb.getNdbError());
2411     return NDBT_FAILED;
2412   }
2413
2414   NdbScanOperation* pOp = pScanTrans->getNdbScanOperation("ACCOUNT");
2415   if (pOp == NULL) {
2416     ERR(pScanTrans->getNdbError());
2417     m_ndb.closeTransaction(pScanTrans);
2418     return NDBT_FAILED;
2419   }
2420
2421   if( pOp->readTuplesExclusive() ) {
2422     ERR(pScanTrans->getNdbError());
2423     m_ndb.closeTransaction(pScanTrans);
2424     return NDBT_FAILED;
2425   }
2426
2427   check = pOp->interpret_exit_ok();
2428   if( check == -1 ) {
2429     ERR(pScanTrans->getNdbError());
2430     m_ndb.closeTransaction(pScanTrans);
2431     return NDBT_FAILED;
2432   }
2433
2434   NdbRecAttr* balanceRec = pOp->getValue("BALANCE");
2435   if( balanceRec ==NULL ) {
2436     ERR(pScanTrans->getNdbError());
2437     m_ndb.closeTransaction(pScanTrans);
2438     return NDBT_FAILED;
2439   }
2440
2441   check = pScanTrans->execute(NoCommit);
2442   if( check == -1 ) {
2443     ERR(pScanTrans->getNdbError());
2444     m_ndb.closeTransaction(pScanTrans);
2445     return NDBT_FAILED;
2446   }
2447
2448   NdbConnection* pTrans = m_ndb.startTransaction();
2449   if (pTrans == NULL) {
2450     ERR(m_ndb.getNdbError());
2451     m_ndb.closeTransaction(pScanTrans);
2452     return NDBT_FAILED;
2453   }
2454
2455   int eof;
2456   eof = pOp->nextResult();
2457
2458   while(eof == 0){
2459     Uint32 b = balanceRec->u_32_value();
2460
2461     sumAccounts += b;
2462     numAccounts++;
2463
2464     //    ndbout << numAccounts << ": balance =" << b
2465     //     << ", sum="<< sumAccounts << endl;
2466
2467     // Take over the operation so that the lock is kept in db
2468     NdbOperation* pLockOp = pOp->updateCurrentTuple(pTrans);
2469     if (pLockOp == NULL){
2470       ERR(m_ndb.getNdbError());
2471       m_ndb.closeTransaction(pScanTrans);
2472       m_ndb.closeTransaction(pTrans);
2473       return NDBT_FAILED;
2474     }
2475
2476     Uint32 illegalBalance = 99;
2477     check = pLockOp->setValue("BALANCE", illegalBalance);
2478     if( check == -1 ) {
2479       ERR(pTrans->getNdbError());
2480       m_ndb.closeTransaction(pTrans);
2481       m_ndb.closeTransaction(pScanTrans);
2482       return NDBT_FAILED;
2483     }
2484
2485     // Execute transaction
2486     check = pTrans->execute(NoCommit);
2487     if( check == -1 ) {
2488       ERR(pTrans->getNdbError());
2489       m_ndb.closeTransaction(pScanTrans);
2490       m_ndb.closeTransaction(pTrans);
2491       return NDBT_FAILED;
2492     }
2493
2494     eof = pOp->nextResult();
2495   }
2496   if (eof == -1) {
2497     ERR(pScanTrans->getNdbError());
2498     m_ndb.closeTransaction(pScanTrans);
2499     m_ndb.closeTransaction(pTrans);
2500     return NDBT_FAILED;
2501   }
2502
2503   // TODO Forget about rolling back, just close pTrans!!
2504
2505   // Rollback transaction
2506   check = pTrans->execute(Rollback);
2507   if( check == -1 ) {
2508     ERR(pTrans->getNdbError());
2509     m_ndb.closeTransaction(pScanTrans);
2510     m_ndb.closeTransaction(pTrans);
2511     return NDBT_FAILED;
2512   }
2513
2514   m_ndb.closeTransaction(pScanTrans);
2515   m_ndb.closeTransaction(pTrans);
2516
2517
2518   return NDBT_OK;
2519
2520 }