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

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

MySQL数据库

开发平台：

Visual C++

HugoTransactions.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 "HugoTransactions.hpp"
  18. #include <NdbSleep.h>
  21. HugoTransactions::HugoTransactions(const NdbDictionary::Table& _tab):
  22.   HugoOperations(_tab),
  23.   row(_tab){
  25.   m_defaultScanUpdateMethod = 3;
  26. }
  28. HugoTransactions::~HugoTransactions(){
  29.   deallocRows();
  30. }
  32. int
  33. HugoTransactions::scanReadRecords(Ndb* pNdb, 
  34.   int records,
  35.   int abortPercent,
  36.   int parallelism, 
  37.   NdbOperation::LockMode lm)
  38. {
  39.   
  40.   int                  retryAttempt = 0;
  41.   const int            retryMax = 100;
  42.   int                  check, a;
  43.   NdbScanOperation        *pOp;
  45.   while (true){
  47.     if (retryAttempt >= retryMax){
  48.       g_err << "ERROR: has retried this operation " << retryAttempt 
  49.     << " times, failing!" << endl;
  50.       return NDBT_FAILED;
  51.     }
  53.     pTrans = pNdb->startTransaction();
  54.     if (pTrans == NULL) {
  55.       const NdbError err = pNdb->getNdbError();
  57.       if (err.status == NdbError::TemporaryError){
  58. ERR(err);
  59. NdbSleep_MilliSleep(50);
  60. retryAttempt++;
  61. continue;
  62.       }
  63.       ERR(err);
  64.       return NDBT_FAILED;
  65.     }
  67.     pOp = pTrans->getNdbScanOperation(tab.getName());
  68.     if (pOp == NULL) {
  69.       ERR(pTrans->getNdbError());
  70.       closeTransaction(pNdb);
  71.       return NDBT_FAILED;
  72.     }
  74.     NdbResultSet * rs;
  75.     rs = pOp ->readTuples(lm);
  77.     if( rs == 0 ) {
  78.       ERR(pTrans->getNdbError());
  79.       closeTransaction(pNdb);
  80.       return NDBT_FAILED;
  81.     }
  82.     
  83.     check = pOp->interpret_exit_ok();
  84.     if( check == -1 ) {
  85.       ERR(pTrans->getNdbError());
  86.       closeTransaction(pNdb);
  87.       return NDBT_FAILED;
  88.     }
  89.   
  90.     for(a = 0; a<tab.getNoOfColumns(); a++){
  91.       if((row.attributeStore(a) = 
  92.   pOp->getValue(tab.getColumn(a)->getName())) == 0) {
  93. ERR(pTrans->getNdbError());
  94. closeTransaction(pNdb);
  95. return NDBT_FAILED;
  96.       }
  97.     }
  99.     check = pTrans->execute(NoCommit);
  100.     if( check == -1 ) {
  101.       const NdbError err = pTrans->getNdbError();
  102.       if (err.status == NdbError::TemporaryError){
  103. ERR(err);
  104. closeTransaction(pNdb);
  105. NdbSleep_MilliSleep(50);
  106. retryAttempt++;
  107. continue;
  108.       }
  109.       ERR(err);
  110.       closeTransaction(pNdb);
  111.       return NDBT_FAILED;
  112.     }
  114.     // Abort after 1-100 or 1-records rows
  115.     int ranVal = rand();
  116.     int abortCount = ranVal % (records == 0 ? 100 : records); 
  117.     bool abortTrans = false;
  118.     if (abort > 0){
  119.       // Abort if abortCount is less then abortPercent 
  120.       if (abortCount < abortPercent) 
  121. abortTrans = true;
  122.     }
  123.     
  124.     int eof;
  125.     int rows = 0;
  126.     while((eof = rs->nextResult(true)) == 0){
  127.       rows++;
  128.       if (calc.verifyRowValues(&row) != 0){
  129. closeTransaction(pNdb);
  130. return NDBT_FAILED;
  131.       }
  133.       if (abortCount == rows && abortTrans == true){
  134. ndbout << "Scan is aborted" << endl;
  135. g_info << "Scan is aborted" << endl;
  136. rs->close();
  137. if( check == -1 ) {
  138.   ERR(pTrans->getNdbError());
  139.   closeTransaction(pNdb);
  140.   return NDBT_FAILED;
  141. }
  143. closeTransaction(pNdb);
  144. return NDBT_OK;
  145.       }
  146.     }
  147.     if (eof == -1) {
  148.       const NdbError err = pTrans->getNdbError();
  149.       
  150.       if (err.status == NdbError::TemporaryError){
  151. ERR_INFO(err);
  152. closeTransaction(pNdb);
  153. NdbSleep_MilliSleep(50);
  154. switch (err.code){
  155. case 488:
  156. case 245:
  157. case 490:
  158.   // Too many active scans, no limit on number of retry attempts
  159.   break;
  160. default:
  161.   retryAttempt++;
  162. }
  163. continue;
  164.       }
  165.       ERR(err);
  166.       closeTransaction(pNdb);
  167.       return NDBT_FAILED;
  168.     }
  170.     closeTransaction(pNdb);
  172.     g_info << rows << " rows have been read" << endl;
  173.     if (records != 0 && rows != records){
  174.       g_err << "Check expected number of records failed" << endl 
  175.     << "  expected=" << records <<", " << endl
  176.     << "  read=" << rows << endl;
  177.       return NDBT_FAILED;
  178.     }
  179.     
  180.     return NDBT_OK;
  181.   }
  182.   return NDBT_FAILED;
  183. }
  185. int
  186. HugoTransactions::scanReadRecords(Ndb* pNdb, 
  187.   const NdbDictionary::Index * pIdx,
  188.   int records,
  189.   int abortPercent,
  190.   int parallelism, 
  191.   NdbOperation::LockMode lm,
  192.   bool sorted)
  193. {
  194.   
  195.   int                  retryAttempt = 0;
  196.   const int            retryMax = 100;
  197.   int                  check, a;
  198.   NdbIndexScanOperation        *pOp;
  200.   while (true){
  202.     if (retryAttempt >= retryMax){
  203.       g_err << "ERROR: has retried this operation " << retryAttempt 
  204.     << " times, failing!" << endl;
  205.       return NDBT_FAILED;
  206.     }
  208.     pTrans = pNdb->startTransaction();
  209.     if (pTrans == NULL) {
  210.       const NdbError err = pNdb->getNdbError();
  212.       if (err.status == NdbError::TemporaryError){
  213. ERR(err);
  214. NdbSleep_MilliSleep(50);
  215. retryAttempt++;
  216. continue;
  217.       }
  218.       ERR(err);
  219.       return NDBT_FAILED;
  220.     }
  222.     pOp = pTrans->getNdbIndexScanOperation(pIdx->getName(), tab.getName());
  223.     if (pOp == NULL) {
  224.       ERR(pTrans->getNdbError());
  225.       closeTransaction(pNdb);
  226.       return NDBT_FAILED;
  227.     }
  229.     NdbResultSet * rs;
  230.     rs = pOp ->readTuples(lm, 0, parallelism, sorted);
  232.     if( rs == 0 ) {
  233.       ERR(pTrans->getNdbError());
  234.       closeTransaction(pNdb);
  235.       return NDBT_FAILED;
  236.     }
  237.     
  238.     check = pOp->interpret_exit_ok();
  239.     if( check == -1 ) {
  240.       ERR(pTrans->getNdbError());
  241.       closeTransaction(pNdb);
  242.       return NDBT_FAILED;
  243.     }
  244.   
  245.     for(a = 0; a<tab.getNoOfColumns(); a++){
  246.       if((row.attributeStore(a) = 
  247.   pOp->getValue(tab.getColumn(a)->getName())) == 0) {
  248. ERR(pTrans->getNdbError());
  249. closeTransaction(pNdb);
  250. return NDBT_FAILED;
  251.       }
  252.     }
  254.     check = pTrans->execute(NoCommit);
  255.     if( check == -1 ) {
  256.       const NdbError err = pTrans->getNdbError();
  257.       if (err.status == NdbError::TemporaryError){
  258. ERR(err);
  259. closeTransaction(pNdb);
  260. NdbSleep_MilliSleep(50);
  261. retryAttempt++;
  262. continue;
  263.       }
  264.       ERR(err);
  265.       closeTransaction(pNdb);
  266.       return NDBT_FAILED;
  267.     }
  269.     // Abort after 1-100 or 1-records rows
  270.     int ranVal = rand();
  271.     int abortCount = ranVal % (records == 0 ? 100 : records); 
  272.     bool abortTrans = false;
  273.     if (abort > 0){
  274.       // Abort if abortCount is less then abortPercent 
  275.       if (abortCount < abortPercent) 
  276. abortTrans = true;
  277.     }
  278.     
  279.     int eof;
  280.     int rows = 0;
  281.     while((eof = rs->nextResult(true)) == 0){
  282.       rows++;
  283.       if (calc.verifyRowValues(&row) != 0){
  284. closeTransaction(pNdb);
  285. return NDBT_FAILED;
  286.       }
  288.       if (abortCount == rows && abortTrans == true){
  289. ndbout << "Scan is aborted" << endl;
  290. g_info << "Scan is aborted" << endl;
  291. rs->close();
  292. if( check == -1 ) {
  293.   ERR(pTrans->getNdbError());
  294.   closeTransaction(pNdb);
  295.   return NDBT_FAILED;
  296. }
  298. closeTransaction(pNdb);
  299. return NDBT_OK;
  300.       }
  301.     }
  302.     if (eof == -1) {
  303.       const NdbError err = pTrans->getNdbError();
  304.       
  305.       if (err.status == NdbError::TemporaryError){
  306. ERR_INFO(err);
  307. closeTransaction(pNdb);
  308. NdbSleep_MilliSleep(50);
  309. switch (err.code){
  310. case 488:
  311. case 245:
  312. case 490:
  313.   // Too many active scans, no limit on number of retry attempts
  314.   break;
  315. default:
  316.   retryAttempt++;
  317. }
  318. continue;
  319.       }
  320.       ERR(err);
  321.       closeTransaction(pNdb);
  322.       return NDBT_FAILED;
  323.     }
  325.     closeTransaction(pNdb);
  327.     g_info << rows << " rows have been read" << endl;
  328.     if (records != 0 && rows != records){
  329.       g_err << "Check expected number of records failed" << endl 
  330.     << "  expected=" << records <<", " << endl
  331.     << "  read=" << rows << endl;
  332.       return NDBT_FAILED;
  333.     }
  334.     
  335.     return NDBT_OK;
  336.   }
  337.   return NDBT_FAILED;
  338. }
  341. #define RESTART_SCAN 99
  343. int
  344. HugoTransactions::scanUpdateRecords(Ndb* pNdb, 
  345.     int records,
  346.     int abortPercent,
  347.     int parallelism){
  348.   if(m_defaultScanUpdateMethod == 1){
  349.     return scanUpdateRecords1(pNdb, records, abortPercent, parallelism);
  350.   } else if(m_defaultScanUpdateMethod == 2){
  351.     return scanUpdateRecords2(pNdb, records, abortPercent, parallelism);
  352.   } else {
  353.     return scanUpdateRecords3(pNdb, records, abortPercent, parallelism);
  354.   }
  355. }
  357. // Scan all records exclusive and update 
  358. // them one by one
  359. int
  360. HugoTransactions::scanUpdateRecords1(Ndb* pNdb, 
  361.      int records,
  362.      int abortPercent,
  363.      int parallelism){
  364. #if 1
  365.   return scanUpdateRecords3(pNdb, records, abortPercent, 1);
  366. #else
  367.   int                  retryAttempt = 0;
  368.   const int            retryMax = 100;
  369.   int check, a;
  370.   NdbOperation *pOp;
  373.   while (true){
  375.     if (retryAttempt >= retryMax){
  376.       g_info << "ERROR: has retried this operation " << retryAttempt 
  377.      << " times, failing!" << endl;
  378.       return NDBT_FAILED;
  379.     }
  381.     pTrans = pNdb->startTransaction();
  382.     if (pTrans == NULL) {
  383.       const NdbError err = pNdb->getNdbError();
  385.       if (err.status == NdbError::TemporaryError){
  386. ERR(err);
  387. NdbSleep_MilliSleep(50);
  388. retryAttempt++;
  389. continue;
  390.       }
  391.       ERR(err);
  392.       return NDBT_FAILED;
  393.     }
  395.     pOp = pTrans->getNdbOperation(tab.getName());
  396.     if (pOp == NULL) {
  397.       ERR(pTrans->getNdbError());
  398.       closeTransaction(pNdb);
  399.       return NDBT_FAILED;
  400.     }
  402.     check = pOp->openScanExclusive(parallelism);
  403.     if( check == -1 ) {
  404.       ERR(pTrans->getNdbError());
  405.       closeTransaction(pNdb);
  406.       return NDBT_FAILED;
  407.     }
  409.     check = pOp->interpret_exit_ok();
  410.     if( check == -1 ) {
  411.       ERR(pTrans->getNdbError());
  412.       closeTransaction(pNdb);
  413.       return NDBT_FAILED;
  414.     }
  416.     // Read all attributes from this table    
  417.     for(a=0; a<tab.getNoOfColumns(); a++){
  418.       if((row.attributeStore(a) = pOp->getValue(tab.getColumn(a)->getName())) == NULL){
  419. ERR(pTrans->getNdbError());
  420. closeTransaction(pNdb);
  421. return NDBT_FAILED;
  422.       }
  423.     }
  425.     check = pTrans->executeScan();   
  426.     if( check == -1 ) {
  427.       const NdbError err = pTrans->getNdbError();
  428.       if (err.status == NdbError::TemporaryError){
  429. ERR(err);
  430. closeTransaction(pNdb);
  431. NdbSleep_MilliSleep(50);
  432. retryAttempt++;
  433. continue;
  434.       }
  435.       ERR(err);
  436.       closeTransaction(pNdb);
  437.       return NDBT_FAILED;
  438.     }
  440.     // Abort after 1-100 or 1-records rows
  441.     int ranVal = rand();
  442.     int abortCount = ranVal % (records == 0 ? 100 : records); 
  443.     bool abortTrans = false;
  444.     if (abort > 0){
  445.       // Abort if abortCount is less then abortPercent 
  446.       if (abortCount < abortPercent) 
  447. abortTrans = true;
  448.     }
  450.   
  451.     int eof;
  452.     int rows = 0;
  454.     eof = pTrans->nextScanResult();
  455.     while(eof == 0){
  456.       rows++;
  457.       
  458.       if (abortCount == rows && abortTrans == true){
  459. g_info << "Scan is aborted" << endl;
  460. // This scan should be aborted
  461. check = pTrans->stopScan();
  462. if( check == -1 ) {
  463.   ERR(pTrans->getNdbError());
  464.   closeTransaction(pNdb);
  465.   return NDBT_FAILED;
  466. }
  468. closeTransaction(pNdb);
  469. return NDBT_OK;
  470.       }
  471.       int res = takeOverAndUpdateRecord(pNdb, pOp);
  472.       if(res == RESTART_SCAN){
  473. eof = -2;
  474. continue;
  475.       }
  476.       if (res != 0){
  477. closeTransaction(pNdb);
  478. return res;
  479.       }
  480.       
  481.       eof = pTrans->nextScanResult();
  482.     }  
  483.     if (eof == -1) {
  484.       const NdbError err = pTrans->getNdbError();
  486.       if (err.status == NdbError::TemporaryError){
  487. ERR(err);
  488. NdbSleep_MilliSleep(50);
  489. switch (err.code){
  490. case 488:
  491. case 245:
  492. case 490:
  493.   // Too many active scans, no limit on number of retry attempts
  494.   break;
  495. default:
  496.   retryAttempt++;
  497. }
  498. continue;
  499.       }
  500.       ERR(err);
  501.       closeTransaction(pNdb);
  502.       return NDBT_FAILED;
  503.     }
  505.     if(eof == -2){
  506.       closeTransaction(pNdb);
  507.       NdbSleep_MilliSleep(50);
  508.       retryAttempt++;
  509.       continue;
  510.     }
  511.     
  512.     closeTransaction(pNdb);
  514.     g_info << rows << " rows have been updated" << endl;
  515.     return NDBT_OK;
  516.   }
  517.   return NDBT_FAILED;
  518. #endif
  519. }
  521. // Scan all records exclusive and update 
  522. // them batched by asking nextScanResult to
  523. // give us all cached records before fetching new 
  524. // records from db
  525. int
  526. HugoTransactions::scanUpdateRecords2(Ndb* pNdb, 
  527.      int records,
  528.      int abortPercent,
  529.      int parallelism){
  530. #if 1
  531.   return scanUpdateRecords3(pNdb, records, abortPercent, parallelism);
  532. #else
  533.   int                  retryAttempt = 0;
  534.   const int            retryMax = 100;
  535.   int check, a;
  536.   NdbOperation *pOp;
  539.   while (true){
  541.     if (retryAttempt >= retryMax){
  542.       g_info << "ERROR: has retried this operation " << retryAttempt 
  543.      << " times, failing!" << endl;
  544.       return NDBT_FAILED;
  545.     }
  547.     pTrans = pNdb->startTransaction();
  548.     if (pTrans == NULL) {
  549.       const NdbError err = pNdb->getNdbError();
  551.       if (err.status == NdbError::TemporaryError){
  552. ERR(err);
  553. NdbSleep_MilliSleep(50);
  554. retryAttempt++;
  555. continue;
  556.       }
  557.       ERR(err);
  558.       return NDBT_FAILED;
  559.     }
  561.     pOp = pTrans->getNdbOperation(tab.getName());
  562.     if (pOp == NULL) {
  563.       ERR(pTrans->getNdbError());
  564.       closeTransaction(pNdb);
  565.       return NDBT_FAILED;
  566.     }
  568.     check = pOp->openScanExclusive(parallelism);
  569.     if( check == -1 ) {
  570.       ERR(pTrans->getNdbError());
  571.       closeTransaction(pNdb);
  572.       return NDBT_FAILED;
  573.     }
  575.     check = pOp->interpret_exit_ok();
  576.     if( check == -1 ) {
  577.       ERR(pTrans->getNdbError());
  578.       closeTransaction(pNdb);
  579.       return NDBT_FAILED;
  580.     }
  582.     // Read all attributes from this table    
  583.     for(a=0; a<tab.getNoOfColumns(); a++){
  584.       if((row.attributeStore(a) = pOp->getValue(tab.getColumn(a)->getName())) == NULL){
  585. ERR(pTrans->getNdbError());
  586. closeTransaction(pNdb);
  587. return NDBT_FAILED;
  588.       }
  589.     }
  591.     check = pTrans->executeScan();   
  592.     if( check == -1 ) {
  593.       const NdbError err = pTrans->getNdbError();
  594.       if (err.status == NdbError::TemporaryError){
  595. ERR(err);
  596. closeTransaction(pNdb);
  597. NdbSleep_MilliSleep(50);
  598. retryAttempt++;
  599. continue;
  600.       }
  601.       ERR(err);
  602.       closeTransaction(pNdb);
  603.       return NDBT_FAILED;
  604.     }
  605.   
  606.     // Abort after 1-100 or 1-records rows
  607.     int ranVal = rand();
  608.     int abortCount = ranVal % (records == 0 ? 100 : records); 
  609.     bool abortTrans = false;
  610.     if (abort > 0){
  611.       // Abort if abortCount is less then abortPercent 
  612.       if (abortCount < abortPercent) 
  613. abortTrans = true;
  614.     }
  616.     int eof;
  617.     int rows = 0;
  619.     while((eof = pTrans->nextScanResult(true)) == 0){
  620.       pUpTrans = pNdb->startTransaction();
  621.       if (pUpTrans == NULL) {
  622. const NdbError err = pNdb->getNdbError();
  624. if (err.status == NdbError::TemporaryError){
  625.   ERR(err);
  626.   NdbSleep_MilliSleep(50);
  627.   retryAttempt++;
  628.   continue;
  629. }
  630. ERR(err);
  631. return NDBT_FAILED;
  632.       }
  633.       do {
  634. rows++;
  635. if (addRowToUpdate(pNdb, pUpTrans, pOp) != 0){
  636.   pNdb->closeTransaction(pUpTrans);
  637.   closeTransaction(pNdb);
  638.   return NDBT_FAILED;
  639. }
  640.       } while((eof = pTrans->nextScanResult(false)) == 0);
  642.       if (abortCount == rows && abortTrans == true){
  643. g_info << "Scan is aborted" << endl;
  644. // This scan should be aborted
  645. check = pTrans->stopScan();
  646. if( check == -1 ) {
  647.   ERR(pTrans->getNdbError());
  648.   closeTransaction(pNdb);
  649.   pNdb->closeTransaction(pUpTrans);
  650.   return NDBT_FAILED;
  651. }
  653. closeTransaction(pNdb);
  654. pNdb->closeTransaction(pUpTrans);
  655. return NDBT_OK;
  656.       }
  658.       check = pUpTrans->execute(Commit);   
  659.       if( check == -1 ) {
  660. const NdbError err = pUpTrans->getNdbError();    
  661. ERR(err);
  662. pNdb->closeTransaction(pUpTrans);
  663. closeTransaction(pNdb);
  664. return NDBT_FAILED;
  665.       }
  666.       pNdb->closeTransaction(pUpTrans);
  667.     }
  668.     if (eof == -1) {
  669.       const NdbError err = pTrans->getNdbError();
  671.       if (err.status == NdbError::TemporaryError){
  672. ERR(err);
  673. closeTransaction(pNdb);
  674. NdbSleep_MilliSleep(50);
  675. retryAttempt++;
  676. continue;
  677.       }
  678.       ERR(err);
  679.       closeTransaction(pNdb);
  680.       return NDBT_FAILED;
  681.     }
  683.     closeTransaction(pNdb);
  685.     g_info << rows << " rows have been updated" << endl;
  686.     return NDBT_OK;
  687.   }
  688.   return NDBT_FAILED;
  689. #endif
  690. }
  692. int
  693. HugoTransactions::scanUpdateRecords3(Ndb* pNdb, 
  694.      int records,
  695.      int abortPercent,
  696.      int parallelism){
  697.   int                  retryAttempt = 0;
  698.   const int            retryMax = 100;
  699.   int check, a;
  700.   NdbScanOperation *pOp;
  703.   while (true){
  704. restart:
  705.     if (retryAttempt++ >= retryMax){
  706.       g_info << "ERROR: has retried this operation " << retryAttempt 
  707.      << " times, failing!" << endl;
  708.       return NDBT_FAILED;
  709.     }
  711.     pTrans = pNdb->startTransaction();
  712.     if (pTrans == NULL) {
  713.       const NdbError err = pNdb->getNdbError();
  714.       ERR(err);
  715.       if (err.status == NdbError::TemporaryError){
  716. NdbSleep_MilliSleep(50);
  717. continue;
  718.       }
  719.       return NDBT_FAILED;
  720.     }
  722.     pOp = pTrans->getNdbScanOperation(tab.getName());
  723.     if (pOp == NULL) {
  724.       ERR(pTrans->getNdbError());
  725.       closeTransaction(pNdb);
  726.       return NDBT_FAILED;
  727.     }
  728.     
  729.     NdbResultSet *rs = pOp->readTuplesExclusive(parallelism);
  730.     if( rs == 0 ) {
  731.       ERR(pTrans->getNdbError());
  732.       closeTransaction(pNdb);
  733.       return NDBT_FAILED;
  734.     }
  735.     
  736.     // Read all attributes from this table    
  737.     for(a=0; a<tab.getNoOfColumns(); a++){
  738.       if((row.attributeStore(a) = pOp->getValue(tab.getColumn(a)->getName())) == NULL){
  739. ERR(pTrans->getNdbError());
  740. closeTransaction(pNdb);
  741. return NDBT_FAILED;
  742.       }
  743.     }
  744.     
  745.     check = pTrans->execute(NoCommit);
  746.     if( check == -1 ) {
  747.       const NdbError err = pTrans->getNdbError();
  748.       ERR(err);
  749.       closeTransaction(pNdb);
  750.       if (err.status == NdbError::TemporaryError){
  751. NdbSleep_MilliSleep(50);
  752. continue;
  753.       }
  754.       return NDBT_FAILED;
  755.     }
  756.   
  757.     // Abort after 1-100 or 1-records rows
  758.     int ranVal = rand();
  759.     int abortCount = ranVal % (records == 0 ? 100 : records); 
  760.     bool abortTrans = false;
  761.     if (abort > 0){
  762.       // Abort if abortCount is less then abortPercent 
  763.       if (abortCount < abortPercent) 
  764. abortTrans = true;
  765.     }
  766.     
  767.     int rows = 0;
  768.     while((check = rs->nextResult(true)) == 0){
  769.       do {
  770. rows++;
  771. NdbOperation* pUp = rs->updateTuple();
  772. if(pUp == 0){
  773.   ERR(pTrans->getNdbError());
  774.   closeTransaction(pNdb);
  775.   return NDBT_FAILED;
  776. }
  777. const int updates = calc.getUpdatesValue(&row) + 1;
  778. const int r = calc.getIdValue(&row);
  779.    for(a = 0; a<tab.getNoOfColumns(); a++){
  780.   if (tab.getColumn(a)->getPrimaryKey() == false){
  781.     if(setValueForAttr(pUp, a, r, updates ) != 0){
  782.       ERR(pTrans->getNdbError());
  783.       closeTransaction(pNdb);
  784.       return NDBT_FAILED;
  785.     }
  786.   }
  787. }
  789. if (rows == abortCount && abortTrans == true){
  790.   g_info << "Scan is aborted" << endl;
  791.   // This scan should be aborted
  792.   closeTransaction(pNdb);
  793.   return NDBT_OK;
  794. }
  795.       } while((check = rs->nextResult(false)) == 0);
  797.       if(check != -1){
  798. check = pTrans->execute(Commit);   
  799. pTrans->restart();
  800.       }
  802.       const NdbError err = pTrans->getNdbError();    
  803.       if( check == -1 ) {
  804. closeTransaction(pNdb);
  805. ERR(err);
  806. if (err.status == NdbError::TemporaryError){
  807.   NdbSleep_MilliSleep(50);
  808.   goto restart;
  809. }
  810. return NDBT_FAILED;
  811.       }
  812.     }
  813.     
  814.     const NdbError err = pTrans->getNdbError();    
  815.     if( check == -1 ) {
  816.       closeTransaction(pNdb);
  817.       ERR(err);
  818.       if (err.status == NdbError::TemporaryError){
  819. NdbSleep_MilliSleep(50);
  820. goto restart;
  821.       }
  822.       return NDBT_FAILED;
  823.     }
  824.     
  825.     closeTransaction(pNdb);
  826.     
  827.     g_info << rows << " rows have been updated" << endl;
  828.     return NDBT_OK;
  829.   }
  830.   return NDBT_FAILED;
  831. }
  833. int
  834. HugoTransactions::loadTable(Ndb* pNdb, 
  835.     int records,
  836.     int batch,
  837.     bool allowConstraintViolation,
  838.     int doSleep,
  839.                             bool oneTrans){
  840.   int             check, a;
  841.   int             retryAttempt = 0;
  842.   int             retryMax = 5;
  843.   NdbOperation   *pOp;
  844.   bool            first_batch = true;
  846.   const int org = batch;
  847.   const int cols = tab.getNoOfColumns();
  848.   const int brow = tab.getRowSizeInBytes();
  849.   const int bytes = 12 + brow + 4 * cols;
  850.   batch = (batch * 256); // -> 512 -> 65536k per commit
  851.   batch = batch/bytes;   // 
  852.   batch = batch == 0 ? 1 : batch;
  853.  
  854.   if(batch != org){
  855.     g_info << "batch = " << org << " rowsize = " << bytes
  856.    << " -> rows/commit = " << batch << endl;
  857.   }
  858.   
  859.   g_info << "|- Inserting records..." << endl;
  860.   for (int c=0 ; c<records ; ){
  861.     bool closeTrans;
  862.     if (retryAttempt >= retryMax){
  863.       g_info << "Record " << c << " could not be inserted, has retried "
  864.      << retryAttempt << " times " << endl;
  865.       // Reset retry counters and continue with next record
  866.       retryAttempt = 0;
  867.       c++;
  868.     }
  869.     if (doSleep > 0)
  870.       NdbSleep_MilliSleep(doSleep);
  872.     //    if (first_batch || !oneTrans) {
  873.     if (first_batch || !pTrans) {
  874.       first_batch = false;
  875.       pTrans = pNdb->startTransaction();
  876.       if (pTrans == NULL) {
  877.         const NdbError err = pNdb->getNdbError();
  879.         if (err.status == NdbError::TemporaryError){
  880.           ERR(err);
  881.   NdbSleep_MilliSleep(50);
  882.   retryAttempt++;
  883.   continue;
  884.         }
  885.         ERR(err);
  886.         return NDBT_FAILED;
  887.       }
  888.     }
  890.     for(int b = 0; b < batch && c+b<records; b++){ 
  892.       pOp = pTrans->getNdbOperation(tab.getName());
  893.       if (pOp == NULL) {
  894. ERR(pTrans->getNdbError());
  895. closeTransaction(pNdb);
  896. return NDBT_FAILED;
  897.       }
  899.       check = pOp->insertTuple();
  900.       if( check == -1 ) {
  901. ERR(pTrans->getNdbError());
  902. closeTransaction(pNdb);
  903. return NDBT_FAILED;
  904.       }
  906.       // Set a calculated value for each attribute in this table  
  907.       for (a = 0; a<tab.getNoOfColumns(); a++){
  908. if(setValueForAttr(pOp, a, c+b, 0 ) != 0){   
  909.   ERR(pTrans->getNdbError());
  910.   closeTransaction(pNdb);
  911.   return NDBT_FAILED;
  912. }
  913.       }
  914.     }
  915.     
  916.     // Execute the transaction and insert the record
  917.     if (!oneTrans || (c + batch) >= records) {
  918.       //      closeTrans = true;
  919.       closeTrans = false;
  920.       check = pTrans->execute( Commit );
  921.       pTrans->restart();
  922.     } else {
  923.       closeTrans = false;
  924.       check = pTrans->execute( NoCommit );
  925.     }
  926.     if(check == -1 ) {
  927.       const NdbError err = pTrans->getNdbError();
  928.       closeTransaction(pNdb);
  929.       pTrans= 0;
  930.       switch(err.status){
  931.       case NdbError::Success:
  932. ERR(err);
  933. g_info << "ERROR: NdbError reports success when transcaction failed"
  934.        << endl;
  935. return NDBT_FAILED;
  936. break;
  938.       case NdbError::TemporaryError:      
  939. ERR(err);
  940. NdbSleep_MilliSleep(50);
  941. retryAttempt++;
  942. continue;
  943. break;
  945.       case NdbError::UnknownResult:
  946. ERR(err);
  947. return NDBT_FAILED;
  948. break;
  950.       case NdbError::PermanentError:
  951. if (allowConstraintViolation == true){
  952.   switch (err.classification){
  953.   case NdbError::ConstraintViolation:
  954.     // Tuple already existed, OK but should be reported
  955.     g_info << c << ": " << err.code << " " << err.message << endl;
  956.     c++;
  957.     continue;
  958.     break;
  959.   default:     
  960.     break;
  961.   }
  962. }
  963. ERR(err);
  964. return err.code;
  965. break;
  966.       }
  967.     }
  968.     else{
  969.       if (closeTrans) {
  970.         closeTransaction(pNdb);
  971. pTrans= 0;
  972.       }
  973.     }
  974.     
  975.     // Step to next record
  976.     c = c+batch; 
  977.     retryAttempt = 0;
  978.   }
  979.   return NDBT_OK;
  980. }
  982. int
  983. HugoTransactions::fillTable(Ndb* pNdb, 
  984.     int batch){
  985.   int             check, a, b;
  986.   int             retryAttempt = 0;
  987.   int             retryMax = 5;
  988.   NdbOperation   *pOp;
  989.   
  990.   g_info << "|- Inserting records..." << endl;
  991.   for (int c=0 ; ; ){
  993.     if (retryAttempt >= retryMax){
  994.       g_info << "Record " << c << " could not be inserted, has retried "
  995.      << retryAttempt << " times " << endl;
  996.       // Reset retry counters and continue with next record
  997.       retryAttempt = 0;
  998.       c++;
  999.     }
  1000.     
  1001.     pTrans = pNdb->startTransaction();
  1002.     if (pTrans == NULL) {
  1003.       const NdbError err = pNdb->getNdbError();
  1005.       if (err.status == NdbError::TemporaryError){
  1006. ERR(err);
  1007. NdbSleep_MilliSleep(50);
  1008. retryAttempt++;
  1009. continue;
  1010.       }
  1011.       ERR(err);
  1012.       return NDBT_FAILED;
  1013.     }
  1015.     for(b = 0; b < batch; b++){ 
  1017.       pOp = pTrans->getNdbOperation(tab.getName());
  1018.       if (pOp == NULL) {
  1019. ERR(pTrans->getNdbError());
  1020. closeTransaction(pNdb);
  1021. return NDBT_FAILED;
  1022.       }
  1024.       check = pOp->insertTuple();
  1025.       if( check == -1 ) {
  1026. ERR(pTrans->getNdbError());
  1027. closeTransaction(pNdb);
  1028. return NDBT_FAILED;
  1029.       }
  1031.       // Set a calculated value for each attribute in this table  
  1032.       for (a = 0; a<tab.getNoOfColumns(); a++){
  1033. if(setValueForAttr(pOp, a, c+b, 0 ) != 0){   
  1034.   ERR(pTrans->getNdbError());
  1035.   closeTransaction(pNdb);
  1036.   return NDBT_FAILED;
  1037. }
  1038.       }
  1039.     }
  1040.     
  1041.     // Execute the transaction and insert the record
  1042.     check = pTrans->execute( Commit, CommitAsMuchAsPossible ); 
  1043.     if(check == -1 ) {
  1044.       const NdbError err = pTrans->getNdbError();
  1045.       closeTransaction(pNdb);
  1046.       
  1047.       switch(err.status){
  1048.       case NdbError::Success:
  1049. ERR(err);
  1050. g_info << "ERROR: NdbError reports success when transcaction failed"
  1051.        << endl;
  1052. return NDBT_FAILED;
  1053. break;
  1055.       case NdbError::TemporaryError:      
  1056. ERR(err);
  1057. NdbSleep_MilliSleep(50);
  1058. retryAttempt++;
  1059. continue;
  1060. break;
  1062.       case NdbError::UnknownResult:
  1063. ERR(err);
  1064. return NDBT_FAILED;
  1065. break;
  1067.       case NdbError::PermanentError:
  1068. //  if (allowConstraintViolation == true){
  1069. //    switch (err.classification){
  1070. //    case NdbError::ConstraintViolation:
  1071. //      // Tuple already existed, OK but should be reported
  1072. //      g_info << c << ": " << err.code << " " << err.message << endl;
  1073. //      c++;
  1074. //      continue;
  1075. //      break;
  1076. //    default:     
  1077. //      break;es
  1078. //     }
  1079. //   }
  1081. // Check if this is the "db full" error 
  1082. if (err.classification==NdbError::InsufficientSpace){
  1083.   ERR(err);
  1084.   return NDBT_OK;
  1085. }
  1087. if (err.classification == NdbError::ConstraintViolation){
  1088.   ERR(err);
  1089.   break;
  1090. }
  1091. ERR(err);
  1092. return NDBT_FAILED;
  1093. break;
  1094.       }
  1095.     }
  1096.     else{      
  1097.       closeTransaction(pNdb);
  1098.     }
  1099.     
  1100.     // Step to next record
  1101.     c = c+batch; 
  1102.     retryAttempt = 0;
  1103.   }
  1104.   return NDBT_OK;
  1105. }
  1107. int 
  1108. HugoTransactions::createEvent(Ndb* pNdb){
  1110.   char eventName[1024];
  1111.   sprintf(eventName,"%s_EVENT",tab.getName());
  1113.   NdbDictionary::Dictionary *myDict = pNdb->getDictionary();
  1115.   if (!myDict) {
  1116.     printf("Event Creation failedDictionary not found");
  1117.     return NDBT_FAILED;
  1118.   }
  1120.   NdbDictionary::Event myEvent(eventName);
  1121.   myEvent.setTable(tab.getName());
  1122.   myEvent.addTableEvent(NdbDictionary::Event::TE_ALL); 
  1123.   //  myEvent.addTableEvent(NdbDictionary::Event::TE_INSERT); 
  1124.   //  myEvent.addTableEvent(NdbDictionary::Event::TE_UPDATE); 
  1125.   //  myEvent.addTableEvent(NdbDictionary::Event::TE_DELETE);
  1127.   //  const NdbDictionary::Table *_table = myDict->getTable(tab.getName());
  1128.   for(int a = 0; a < tab.getNoOfColumns(); a++){
  1129.     //    myEvent.addEventColumn(_table->getColumn(a)->getName());
  1130.     myEvent.addEventColumn(a);
  1131.   }
  1133.   int res = myDict->createEvent(myEvent); // Add event to database
  1135.   if (res == 0)
  1136.     myEvent.print();
  1137.   else {
  1138.     g_info << "Event creation failedn";
  1139.     g_info << "trying drop Event, maybe event existsn";
  1140.     res = myDict->dropEvent(eventName);
  1141.     if (res) {
  1142.       g_err << "failed to drop eventn";
  1143.       return NDBT_FAILED;
  1144.     }
  1145.     // try again
  1146.     res = myDict->createEvent(myEvent); // Add event to database
  1147.     if (res) {
  1148.       g_err << "failed to create eventn";
  1149.       return NDBT_FAILED;
  1150.     }
  1151.   }
  1153.   return NDBT_OK;
  1154. }
  1156. #include <NdbEventOperation.hpp>
  1157. #include "TestNdbEventOperation.hpp"
  1158. #include <NdbAutoPtr.hpp>
  1160. struct receivedEvent {
  1161.   Uint32 pk;
  1162.   Uint32 count;
  1163.   Uint32 event;
  1164. };
  1166. int XXXXX = 0;
  1167. int 
  1168. HugoTransactions::eventOperation(Ndb* pNdb, void* pstats,
  1169.  int records) {
  1170.   int myXXXXX = XXXXX++;
  1171.   Uint32 i;
  1172.   const char function[] = "HugoTransactions::eventOperation: ";
  1173.   struct receivedEvent* recInsertEvent;
  1174.   NdbAutoObjArrayPtr<struct receivedEvent>
  1175.     p00( recInsertEvent = new struct receivedEvent[3*records] );
  1176.   struct receivedEvent* recUpdateEvent = &recInsertEvent[records];
  1177.   struct receivedEvent* recDeleteEvent = &recInsertEvent[2*records];
  1179.   EventOperationStats &stats = *(EventOperationStats*)pstats;
  1181.   stats.n_inserts = 0;
  1182.   stats.n_deletes = 0;
  1183.   stats.n_updates = 0;
  1184.   stats.n_consecutive = 0;
  1185.   stats.n_duplicates = 0;
  1186.   stats.n_inconsistent_gcis = 0;
  1188.   for (i = 0; i < records; i++) {
  1189.     recInsertEvent[i].pk    = 0xFFFFFFFF;
  1190.     recInsertEvent[i].count = 0;
  1191.     recInsertEvent[i].event = 0xFFFFFFFF;
  1193.     recUpdateEvent[i].pk    = 0xFFFFFFFF;
  1194.     recUpdateEvent[i].count = 0;
  1195.     recUpdateEvent[i].event = 0xFFFFFFFF;
  1197.     recDeleteEvent[i].pk    = 0xFFFFFFFF;
  1198.     recDeleteEvent[i].count = 0;
  1199.     recDeleteEvent[i].event = 0xFFFFFFFF;
  1200.   }
  1202.   NdbDictionary::Dictionary *myDict = pNdb->getDictionary();
  1204.   if (!myDict) {
  1205.     g_err << function << "Event Creation failedDictionary not foundn";
  1206.     return NDBT_FAILED;
  1207.   }
  1209.   int                  r = 0;
  1210.   NdbEventOperation    *pOp;
  1212.   char eventName[1024];
  1213.   sprintf(eventName,"%s_EVENT",tab.getName());
  1214.   int noEventColumnName = tab.getNoOfColumns();
  1216.   g_info << function << "create EventOperationn";
  1217.   pOp = pNdb->createEventOperation(eventName, 100);
  1218.   if ( pOp == NULL ) {
  1219.     g_err << function << "Event operation creation failedn";
  1220.     return NDBT_FAILED;
  1221.   }
  1223.   g_info << function << "get valuesn";
  1224.   NdbRecAttr* recAttr[1024];
  1225.   NdbRecAttr* recAttrPre[1024];
  1227.   const NdbDictionary::Table *_table = myDict->getTable(tab.getName());
  1229.   for (int a = 0; a < noEventColumnName; a++) {
  1230.     recAttr[a]    = pOp->getValue(_table->getColumn(a)->getName());
  1231.     recAttrPre[a] = pOp->getPreValue(_table->getColumn(a)->getName());
  1232.   }
  1233.   
  1234.   // set up the callbacks
  1235.   g_info << function << "executen";
  1236.   if (pOp->execute()) { // This starts changes to "start flowing"
  1237.     g_err << function << "operation execution failedn";
  1238.     return NDBT_FAILED;
  1239.   }
  1241.   g_info << function << "okn";
  1243.   int count = 0;
  1244.   Uint32 last_inconsitant_gci = 0xEFFFFFF0;
  1246.   while (r < records){
  1247.     //printf("now waiting for event...n");
  1248.     int res = pNdb->pollEvents(1000); // wait for event or 1000 ms
  1250.     if (res > 0) {
  1251.       //printf("got data! %dn", r);
  1252.       int overrun;
  1253.       while (pOp->next(&overrun) > 0) {
  1254. r++;
  1255. r += overrun;
  1256. count++;
  1258. Uint32 gci = pOp->getGCI();
  1259. Uint32 pk = recAttr[0]->u_32_value();
  1261.         if (!pOp->isConsistent()) {
  1262.   if (last_inconsitant_gci != gci) {
  1263.     last_inconsitant_gci = gci;
  1264.     stats.n_inconsistent_gcis++;
  1265.   }
  1266.   g_warning << "A node failure has occured and events might be missingn";
  1267. }
  1268. g_info << function << "GCI " << gci << ": " << count;
  1269. struct receivedEvent* recEvent;
  1270. switch (pOp->getEventType()) {
  1271. case NdbDictionary::Event::TE_INSERT:
  1272.   stats.n_inserts++;
  1273.   g_info << " INSERT: ";
  1274.   recEvent = recInsertEvent;
  1275.   break;
  1276. case NdbDictionary::Event::TE_DELETE:
  1277.   stats.n_deletes++;
  1278.   g_info << " DELETE: ";
  1279.   recEvent = recDeleteEvent;
  1280.   break;
  1281. case NdbDictionary::Event::TE_UPDATE:
  1282.   stats.n_updates++;
  1283.   g_info << " UPDATE: ";
  1284.   recEvent = recUpdateEvent;
  1285.   break;
  1286. case NdbDictionary::Event::TE_ALL:
  1287.   abort();
  1288. }
  1290. if ((int)pk < records) {
  1291.   recEvent[pk].pk = pk;
  1292.   recEvent[pk].count++;
  1293. }
  1295. g_info << "overrun " << overrun << " pk " << pk;
  1296. for (i = 1; i < noEventColumnName; i++) {
  1297.   if (recAttr[i]->isNULL() >= 0) { // we have a value
  1298.     g_info << " post[" << i << "]=";
  1299.     if (recAttr[i]->isNULL() == 0) // we have a non-null value
  1300.       g_info << recAttr[i]->u_32_value();
  1301.     else                           // we have a null value
  1302.       g_info << "NULL";
  1303.   }
  1304.   if (recAttrPre[i]->isNULL() >= 0) { // we have a value
  1305.     g_info << " pre[" << i << "]=";
  1306.     if (recAttrPre[i]->isNULL() == 0) // we have a non-null value
  1307.       g_info << recAttrPre[i]->u_32_value();
  1308.     else                              // we have a null value
  1309.       g_info << "NULL";
  1310.   }
  1311. }
  1312. g_info << endl;
  1313.       }
  1314.     } else
  1315.       ;//printf("timed outn");
  1316.   }
  1318.   //  sleep ((XXXXX-myXXXXX)*2);
  1320.   g_info << myXXXXX << "dropping event operation" << endl;
  1322.   int res = pNdb->dropEventOperation(pOp);
  1323.   if (res != 0) {
  1324.     g_err << "operation execution failedn";
  1325.     return NDBT_FAILED;
  1326.   }
  1328.   g_info << myXXXXX << " ok" << endl;
  1330.   if (stats.n_inserts > 0) {
  1331.     stats.n_consecutive++;
  1332.   }
  1333.   if (stats.n_deletes > 0) {
  1334.     stats.n_consecutive++;
  1335.   }
  1336.   if (stats.n_updates > 0) {
  1337.     stats.n_consecutive++;
  1338.   }
  1339.   for (i = 0; i < (Uint32)records/3; i++) {
  1340.     if (recInsertEvent[i].pk != i) {
  1341.       stats.n_consecutive ++;
  1342.       ndbout << "missing insert pk " << i << endl;
  1343.     } else if (recInsertEvent[i].count > 1) {
  1344.       ndbout << "duplicates insert pk " << i
  1345.      << " count " << recInsertEvent[i].count << endl;
  1346.       stats.n_duplicates += recInsertEvent[i].count-1;
  1347.     }
  1348.     if (recUpdateEvent[i].pk != i) {
  1349.       stats.n_consecutive ++;
  1350.       ndbout << "missing update pk " << i << endl;
  1351.     } else if (recUpdateEvent[i].count > 1) {
  1352.       ndbout << "duplicates update pk " << i
  1353.      << " count " << recUpdateEvent[i].count << endl;
  1354.       stats.n_duplicates += recUpdateEvent[i].count-1;
  1355.     }
  1356.     if (recDeleteEvent[i].pk != i) {
  1357.       stats.n_consecutive ++;
  1358.       ndbout << "missing delete pk " << i << endl;
  1359.     } else if (recDeleteEvent[i].count > 1) {
  1360.       ndbout << "duplicates delete pk " << i
  1361.      << " count " << recDeleteEvent[i].count << endl;
  1362.       stats.n_duplicates += recDeleteEvent[i].count-1;
  1363.     }
  1364.   }
  1366.   return NDBT_OK;
  1367. }
  1369. int 
  1370. HugoTransactions::pkReadRecords(Ndb* pNdb, 
  1371. int records,
  1372. int batchsize,
  1373. NdbOperation::LockMode lm){
  1374.   int                  reads = 0;
  1375.   int                  r = 0;
  1376.   int                  retryAttempt = 0;
  1377.   const int            retryMax = 100;
  1378.   int                  check, a;
  1379.   NdbOperation        *pOp;
  1381.   if (batchsize == 0) {
  1382.     g_info << "ERROR: Argument batchsize == 0 in pkReadRecords(). Not allowed." << endl;
  1383.     return NDBT_FAILED;
  1384.   }
  1386.   allocRows(batchsize);
  1388.   while (r < records){
  1389.     if (retryAttempt >= retryMax){
  1390.       g_info << "ERROR: has retried this operation " << retryAttempt 
  1391.      << " times, failing!" << endl;
  1392.       return NDBT_FAILED;
  1393.     }
  1395.     pTrans = pNdb->startTransaction();
  1396.     if (pTrans == NULL) {
  1397.       const NdbError err = pNdb->getNdbError();
  1398.       
  1399.       if (err.status == NdbError::TemporaryError){
  1400. ERR(err);
  1401. NdbSleep_MilliSleep(50);
  1402. retryAttempt++;
  1403. continue;
  1404.       }
  1405.       ERR(err);
  1406.       return NDBT_FAILED;
  1407.     }
  1408.     
  1409.     for(int b=0; (b<batchsize) && (r+b < records); b++){
  1410.       pOp = pTrans->getNdbOperation(tab.getName());
  1411.       if (pOp == NULL) {
  1412. ERR(pTrans->getNdbError());
  1413. closeTransaction(pNdb);
  1414. return NDBT_FAILED;
  1415.       }
  1417.   rand_lock_mode:
  1418.       switch(lm){
  1419.       case NdbOperation::LM_Read:
  1420. check = pOp->readTuple();
  1421. break;
  1422.       case NdbOperation::LM_Exclusive:
  1423. check = pOp->readTupleExclusive();
  1424. break;
  1425.       case NdbOperation::LM_CommittedRead:
  1426. check = pOp->dirtyRead();
  1427. break;
  1428.       default:
  1429. lm = (NdbOperation::LockMode)((rand() >> 16) & 3);
  1430. goto rand_lock_mode;
  1431.       }
  1432.       
  1433.       if( check == -1 ) {
  1434. ERR(pTrans->getNdbError());
  1435. closeTransaction(pNdb);
  1436. return NDBT_FAILED;
  1437.       }
  1439.       // Define primary keys
  1440.       for(a = 0; a<tab.getNoOfColumns(); a++){
  1441. if (tab.getColumn(a)->getPrimaryKey() == true){
  1442.   if(equalForAttr(pOp, a, r+b) != 0){
  1443.     ERR(pTrans->getNdbError());
  1444.     closeTransaction(pNdb);
  1445.     return NDBT_FAILED;
  1446.   }
  1447. }
  1448.       }
  1449.     
  1450.       // Define attributes to read  
  1451.       for(a = 0; a<tab.getNoOfColumns(); a++){
  1452. if((rows[b]->attributeStore(a) = 
  1453.     pOp->getValue(tab.getColumn(a)->getName())) == 0) {
  1454.   ERR(pTrans->getNdbError());
  1455.   closeTransaction(pNdb);
  1456.   return NDBT_FAILED;
  1457. }
  1458.       }
  1459.       
  1460.     }
  1462.     check = pTrans->execute(Commit);   
  1463.     if( check == -1 ) {
  1464.       const NdbError err = pTrans->getNdbError();
  1466.       if (err.status == NdbError::TemporaryError){
  1467. ERR(err);
  1468. closeTransaction(pNdb);
  1469. NdbSleep_MilliSleep(50);
  1470. retryAttempt++;
  1471. continue;
  1472.       }
  1473.       switch(err.code){
  1474.       case 626: // Tuple did not exist
  1475. g_info << r << ": " << err.code << " " << err.message << endl;
  1476. r++;
  1477. break;
  1479.       default:
  1480. ERR(err);
  1481. closeTransaction(pNdb);
  1482. return NDBT_FAILED;
  1483.       }
  1484.     } else{
  1485.       for (int b=0; (b<batchsize) && (r+b<records); b++){ 
  1486. if (calc.verifyRowValues(rows[b]) != 0){
  1487.   closeTransaction(pNdb);
  1488.   return NDBT_FAILED;
  1489. }
  1490. reads++;
  1491. r++;
  1492.       }
  1493.     }
  1495.     closeTransaction(pNdb);
  1497.   }
  1498.   deallocRows();
  1499.   g_info << reads << " records read" << endl;
  1500.   return NDBT_OK;
  1501. }
  1505. int 
  1506. HugoTransactions::pkUpdateRecords(Ndb* pNdb, 
  1507.   int records,
  1508.   int batch,
  1509.   int doSleep){
  1510.   int updated = 0;
  1511.   int                  r = 0;
  1512.   int                  retryAttempt = 0;
  1513.   const int            retryMax = 100;
  1514.   int                  check, a, b;
  1515.   NdbOperation        *pOp;
  1517.   allocRows(batch);
  1519.   g_info << "|- Updating records (batch=" << batch << ")..." << endl;
  1520.   while (r < records){
  1521.     
  1522.     if (retryAttempt >= retryMax){
  1523.       g_info << "ERROR: has retried this operation " << retryAttempt 
  1524.      << " times, failing!" << endl;
  1525.       return NDBT_FAILED;
  1526.     }
  1527.     
  1528.     if (doSleep > 0)
  1529.       NdbSleep_MilliSleep(doSleep);
  1531.     pTrans = pNdb->startTransaction();
  1532.     if (pTrans == NULL) {
  1533.       const NdbError err = pNdb->getNdbError();
  1534.       
  1535.       if (err.status == NdbError::TemporaryError){
  1536. ERR(err);
  1537. NdbSleep_MilliSleep(50);
  1538. retryAttempt++;
  1539. continue;
  1540.       }
  1541.       ERR(err);
  1542.       return NDBT_FAILED;
  1543.     }
  1545.     for(b = 0; b<batch && (r+b) < records; b++){
  1546.       pOp = pTrans->getNdbOperation(tab.getName());
  1547.       if (pOp == NULL) {
  1548. ERR(pTrans->getNdbError());
  1549. closeTransaction(pNdb);
  1550. return NDBT_FAILED;
  1551.       }
  1552.       
  1553.       check = pOp->readTupleExclusive();
  1554.       if( check == -1 ) {
  1555. ERR(pTrans->getNdbError());
  1556. closeTransaction(pNdb);
  1557. return NDBT_FAILED;
  1558.       }
  1560.       // Define primary keys
  1561.       for(a = 0; a<tab.getNoOfColumns(); a++){
  1562. if (tab.getColumn(a)->getPrimaryKey() == true){
  1563.   if(equalForAttr(pOp, a, r+b) != 0){
  1564.     ERR(pTrans->getNdbError());
  1565.     closeTransaction(pNdb);
  1566.     return NDBT_FAILED;
  1567.   }
  1568. }
  1569.       }
  1570.       
  1571.       // Define attributes to read  
  1572.       for(a = 0; a<tab.getNoOfColumns(); a++){
  1573. if((rows[b]->attributeStore(a) = 
  1574.     pOp->getValue(tab.getColumn(a)->getName())) == 0) {
  1575.   ERR(pTrans->getNdbError());
  1576.   closeTransaction(pNdb);
  1577.   return NDBT_FAILED;
  1578. }
  1579.       }
  1580.     }
  1582.     check = pTrans->execute(NoCommit);   
  1583.     if( check == -1 ) {
  1584.       const NdbError err = pTrans->getNdbError();
  1585.       
  1586.       if (err.status == NdbError::TemporaryError){
  1587. ERR(err);
  1588. closeTransaction(pNdb);
  1589. NdbSleep_MilliSleep(50);
  1590. retryAttempt++;
  1591. continue;
  1592.       }
  1593.       ERR(err);
  1594.       closeTransaction(pNdb);
  1595.       return NDBT_FAILED;
  1596.     }
  1597.     
  1598.     for(b = 0; b<batch && (b+r)<records; b++){
  1599.       if (calc.verifyRowValues(rows[b]) != 0){
  1600. closeTransaction(pNdb);
  1601. return NDBT_FAILED;
  1602.       }
  1603.       
  1604.       int updates = calc.getUpdatesValue(rows[b]) + 1;
  1605.       
  1606.       NdbOperation* pUpdOp;
  1607.       pUpdOp = pTrans->getNdbOperation(tab.getName());
  1608.       if (pUpdOp == NULL) {
  1609. ERR(pTrans->getNdbError());
  1610. closeTransaction(pNdb);
  1611. return NDBT_FAILED;
  1612.       }
  1613.       
  1614.       check = pUpdOp->updateTuple();
  1615.       if( check == -1 ) {
  1616. ERR(pTrans->getNdbError());
  1617. closeTransaction(pNdb);
  1618. return NDBT_FAILED;
  1619.       }
  1620.       
  1621.       for(a = 0; a<tab.getNoOfColumns(); a++){
  1622. if (tab.getColumn(a)->getPrimaryKey() == true){
  1623.   if(equalForAttr(pUpdOp, a, r+b) != 0){
  1624.     ERR(pTrans->getNdbError());
  1625.     closeTransaction(pNdb);
  1626.     return NDBT_FAILED;
  1627.   }
  1628. }
  1629.       }
  1631.       for(a = 0; a<tab.getNoOfColumns(); a++){
  1632. if (tab.getColumn(a)->getPrimaryKey() == false){
  1633.   if(setValueForAttr(pUpdOp, a, r+b, updates ) != 0){
  1634.     ERR(pTrans->getNdbError());
  1635.     closeTransaction(pNdb);
  1636.     return NDBT_FAILED;
  1637.   }
  1638. }
  1639.       }
  1640.     }
  1642.     check = pTrans->execute(Commit);   
  1643.     if( check == -1 ) {
  1644.       const NdbError err = pTrans->getNdbError();
  1646.       if (err.status == NdbError::TemporaryError){
  1647. ERR(err);
  1648. closeTransaction(pNdb);
  1649. NdbSleep_MilliSleep(50);
  1650. retryAttempt++;
  1651. continue;
  1652.       }
  1653.       ERR(err);
  1654.       ndbout << "r = " << r << endl;
  1655.       closeTransaction(pNdb);
  1656.       return NDBT_FAILED;
  1657.     }
  1658.     else{
  1659.       updated += batch;
  1660.     }
  1663.     closeTransaction(pNdb);
  1665.     r += batch; // Read next record
  1666.   }
  1668.   deallocRows();
  1669.   g_info << "|- " << updated << " records updated" << endl;
  1670.   return NDBT_OK;
  1671. }
  1673. int 
  1674. HugoTransactions::pkInterpretedUpdateRecords(Ndb* pNdb, 
  1675.      int records,
  1676.      int batch){
  1677.   int updated = 0;
  1678.   int r = 0;
  1679.   int retryAttempt = 0;
  1680.   const int retryMax = 100;
  1681.   int check, a;
  1683.   while (r < records){
  1684.     
  1685.     if (retryAttempt >= retryMax){
  1686.       g_info << "ERROR: has retried this operation " << retryAttempt 
  1687.      << " times, failing!" << endl;
  1688.       return NDBT_FAILED;
  1689.     }
  1690.     
  1691.     pTrans = pNdb->startTransaction();
  1692.     if (pTrans == NULL) {
  1693.       const NdbError err = pNdb->getNdbError();
  1694.       
  1695.       if (err.status == NdbError::TemporaryError){
  1696. ERR(err);
  1697. NdbSleep_MilliSleep(50);
  1698. retryAttempt++;
  1699. continue;
  1700.       }
  1701.       ERR(err);
  1702.       return NDBT_FAILED;
  1703.     }
  1705.    NdbOperation* pOp = pTrans->getNdbOperation(tab.getName());
  1706.    if (pOp == NULL) {
  1707.      ERR(pTrans->getNdbError());
  1708.      closeTransaction(pNdb);
  1709.      return NDBT_FAILED;
  1710.    }
  1711.    
  1712.    check = pOp->readTupleExclusive();
  1713.    if( check == -1 ) {
  1714.      ERR(pTrans->getNdbError());
  1715.      closeTransaction(pNdb);
  1716.       return NDBT_FAILED;
  1717.    }
  1718.    
  1719.    // Define primary keys
  1720.    for(a = 0; a<tab.getNoOfColumns(); a++){
  1721.      if (tab.getColumn(a)->getPrimaryKey() == true){
  1722.        if(equalForAttr(pOp, a, r) != 0){
  1723.  ERR(pTrans->getNdbError());
  1724.  closeTransaction(pNdb);
  1725.  return NDBT_FAILED;
  1726.        }
  1727.      }
  1728.    }
  1729.    
  1730.    // Read update value
  1731.    for(a = 0; a<tab.getNoOfColumns(); a++){
  1732.      if (calc.isUpdateCol(a) == true){
  1733.        if((row.attributeStore(a) = 
  1734.    pOp->getValue(tab.getColumn(a)->getName())) == 0) {
  1735.  ERR(pTrans->getNdbError());
  1736.  closeTransaction(pNdb);
  1737.  return NDBT_FAILED;
  1738.        }
  1739.      }
  1740.    }
  1741.    
  1742.     check = pTrans->execute(NoCommit);   
  1743.     if( check == -1 ) {
  1744.       const NdbError err = pTrans->getNdbError();
  1746.       if (err.status == NdbError::TemporaryError){
  1747. ERR(err);
  1748. closeTransaction(pNdb);
  1749. NdbSleep_MilliSleep(50);
  1750. retryAttempt++;
  1751. continue;
  1752.       }
  1753.       ERR(err);
  1754.       closeTransaction(pNdb);
  1755.       return NDBT_FAILED;
  1756.     }
  1758.     int updates = calc.getUpdatesValue(&row) + 1;
  1760.     NdbOperation* pUpdOp;
  1761.     pUpdOp = pTrans->getNdbOperation(tab.getName());
  1762.     if (pUpdOp == NULL) {
  1763.       ERR(pTrans->getNdbError());
  1764.       closeTransaction(pNdb);
  1765.       return NDBT_FAILED;
  1766.     }
  1768.     check = pUpdOp->interpretedUpdateTuple();
  1769.     if( check == -1 ) {
  1770.       ERR(pTrans->getNdbError());
  1771.       closeTransaction(pNdb);
  1772.       return NDBT_FAILED;
  1773.     }
  1775.     // PKs
  1776.     for(a = 0; a<tab.getNoOfColumns(); a++){
  1777.       if (tab.getColumn(a)->getPrimaryKey() == true){
  1778. if(equalForAttr(pUpdOp, a, r) != 0){
  1779.   ERR(pTrans->getNdbError());
  1780.   closeTransaction(pNdb);
  1781.   return NDBT_FAILED;
  1782. }
  1783.       }
  1784.     }
  1786.     // Update col
  1787.     for(a = 0; a<tab.getNoOfColumns(); a++){
  1788.       if ((tab.getColumn(a)->getPrimaryKey() == false) && 
  1789.   (calc.isUpdateCol(a) == true)){
  1791. // TODO switch for 32/64 bit
  1792. const NdbDictionary::Column* attr = tab.getColumn(a);
  1793. Uint32 valToIncWith = 1;
  1794. check = pUpdOp->incValue(attr->getName(), valToIncWith);
  1795. if( check == -1 ) {
  1796.   ERR(pTrans->getNdbError());
  1797.   closeTransaction(pNdb);
  1798.   return NDBT_FAILED;
  1799. }
  1800.       }
  1801.     }
  1803.     // Remaining attributes
  1804.     for(a = 0; a<tab.getNoOfColumns(); a++){
  1805.       if ((tab.getColumn(a)->getPrimaryKey() == false) && 
  1806.   (calc.isUpdateCol(a) == false)){
  1807. if(setValueForAttr(pUpdOp, a, r, updates ) != 0){
  1808.   ERR(pTrans->getNdbError());
  1809.   closeTransaction(pNdb);
  1810.   return NDBT_FAILED;
  1811. }
  1812.       }
  1813.     }
  1816.     
  1817.     check = pTrans->execute(Commit);   
  1818.     if( check == -1 ) {
  1819.       const NdbError err = pTrans->getNdbError();
  1821.       if (err.status == NdbError::TemporaryError){
  1822. ERR(err);
  1823. closeTransaction(pNdb);
  1824. NdbSleep_MilliSleep(50);
  1825. retryAttempt++;
  1826. continue;
  1827.       }
  1828.       ERR(err);
  1829.       ndbout << "r = " << r << endl;
  1830.       closeTransaction(pNdb);
  1831.       return NDBT_FAILED;
  1832.     }
  1833.     else{
  1834.       updated++;
  1835.     }
  1838.     closeTransaction(pNdb);
  1840.     r++; // Read next record
  1842.   }
  1844.   g_info << "|- " << updated << " records updated" << endl;
  1845.   return NDBT_OK;
  1846. }
  1848. int 
  1849. HugoTransactions::pkDelRecords(Ndb* pNdb, 
  1850.        int records,
  1851.        int batch,
  1852.        bool allowConstraintViolation,
  1853.        int doSleep){
  1854.   // TODO Batch is not implemented
  1855.   int deleted = 0;
  1856.   int                  r = 0;
  1857.   int                  retryAttempt = 0;
  1858.   const int            retryMax = 100;
  1859.   int                  check, a;
  1860.   NdbOperation        *pOp;
  1862.   g_info << "|- Deleting records..." << endl;
  1863.   while (r < records){
  1865.     if (retryAttempt >= retryMax){
  1866.       g_info << "ERROR: has retried this operation " << retryAttempt 
  1867.      << " times, failing!" << endl;
  1868.       return NDBT_FAILED;
  1869.     }
  1871.     if (doSleep > 0)
  1872.       NdbSleep_MilliSleep(doSleep);
  1874.     pTrans = pNdb->startTransaction();
  1875.     if (pTrans == NULL) {
  1876.       const NdbError err = pNdb->getNdbError();
  1878.       if (err.status == NdbError::TemporaryError){
  1879. ERR(err);
  1880. NdbSleep_MilliSleep(50);
  1881. retryAttempt++;
  1882. continue;
  1883.       }
  1884.       ERR(err);
  1885.       return NDBT_FAILED;
  1886.     }
  1888.     pOp = pTrans->getNdbOperation(tab.getName());
  1889.     if (pOp == NULL) {
  1890.       ERR(pTrans->getNdbError());
  1891.       closeTransaction(pNdb);
  1892.       return NDBT_FAILED;
  1893.     }
  1895.     check = pOp->deleteTuple();
  1896.     if( check == -1 ) {
  1897.       ERR(pTrans->getNdbError());
  1898.       closeTransaction(pNdb);
  1899.       return NDBT_FAILED;
  1900.     }
  1902.     // Define primary keys
  1903.     for(a = 0; a<tab.getNoOfColumns(); a++){
  1904.       if (tab.getColumn(a)->getPrimaryKey() == true){
  1905. if(equalForAttr(pOp, a, r) != 0){
  1906.   ERR(pTrans->getNdbError());
  1907.   closeTransaction(pNdb);
  1908.   return NDBT_FAILED;
  1909. }
  1910.       }
  1911.     }
  1912.     check = pTrans->execute(Commit);   
  1913.     if( check == -1) {
  1914.       const NdbError err = pTrans->getNdbError();
  1915.       
  1916.       switch(err.status){
  1917.       case NdbError::TemporaryError:
  1918. ERR(err);
  1919. closeTransaction(pNdb);
  1920. NdbSleep_MilliSleep(50);
  1921. retryAttempt++;
  1922. continue;
  1923. break;
  1925.       case NdbError::PermanentError:
  1926. if (allowConstraintViolation == true){
  1927.   switch (err.classification){
  1928.   case NdbError::ConstraintViolation:
  1929.     // Tuple did not exist, OK but should be reported
  1930.     g_info << r << ": " << err.code << " " << err.message << endl;
  1931.     continue;
  1932.     break;
  1933.   default:     
  1934.     break;
  1935.   }
  1936. }
  1937. ERR(err);
  1938. closeTransaction(pNdb);
  1939. return NDBT_FAILED;
  1940. break;
  1942.       default:
  1943. ERR(err);
  1944. closeTransaction(pNdb);
  1945. return NDBT_FAILED;
  1946.       }
  1947.     }
  1948.     else {
  1949.       deleted++;
  1950.     }
  1951.     closeTransaction(pNdb);
  1953.     r++; // Read next record
  1955.   }
  1957.   g_info << "|- " << deleted << " records deleted" << endl;
  1958.   return NDBT_OK;
  1959. }
  1962. int 
  1963. HugoTransactions::lockRecords(Ndb* pNdb, 
  1964.       int records,
  1965.       int percentToLock,
  1966.       int lockTime){
  1967.   // Place a lock on percentToLock% of the records in the Db
  1968.   // Keep the locks for lockTime ms, commit operation
  1969.   // and lock som other records
  1970.   int                  r = 0;
  1971.   int                  retryAttempt = 0;
  1972.   const int            retryMax = 100;
  1973.   int                  check, a, b;
  1974.   NdbOperation        *pOp;
  1976.   // Calculate how many records to lock in each batch
  1977.   if (percentToLock <= 0)
  1978.     percentToLock = 1;
  1979.   double percentVal = (double)percentToLock / 100;
  1980.   int lockBatch = (int)(records * percentVal);
  1981.   if (lockBatch <= 0)
  1982.     lockBatch = 1;
  1984.   allocRows(lockBatch);
  1985.   
  1986.   while (r < records){
  1987.     g_info << "|- Locking " << lockBatch << " records..." << endl;
  1989.     if (retryAttempt >= retryMax){
  1990.       g_info << "ERROR: has retried this operation " << retryAttempt 
  1991.      << " times, failing!" << endl;
  1992.       return NDBT_FAILED;
  1993.     }
  1995.     pTrans = pNdb->startTransaction();
  1996.     if (pTrans == NULL) {
  1997.       const NdbError err = pNdb->getNdbError();
  1999.       if (err.status == NdbError::TemporaryError){
  2000. ERR(err);
  2001. NdbSleep_MilliSleep(50);
  2002. retryAttempt++;
  2003. continue;
  2004.       }
  2005.       ERR(err);
  2006.       return NDBT_FAILED;
  2007.     }
  2009.     for(b = 0; (b<lockBatch) && (r+b < records); b++){ 
  2010.       pOp = pTrans->getNdbOperation(tab.getName());
  2011.       if (pOp == NULL) {
  2012. ERR(pTrans->getNdbError());
  2013. closeTransaction(pNdb);
  2014. return NDBT_FAILED;
  2015.       }
  2016.       
  2017.       check = pOp->readTupleExclusive();
  2018.       if( check == -1 ) {
  2019. ERR(pTrans->getNdbError());
  2020. closeTransaction(pNdb);
  2021. return NDBT_FAILED;
  2022.       }
  2023.       
  2024.       // Define primary keys
  2025.       for(a = 0; a<tab.getNoOfColumns(); a++){
  2026. if (tab.getColumn(a)->getPrimaryKey() == true){
  2027.   if(equalForAttr(pOp, a, r+b) != 0){
  2028.     ERR(pTrans->getNdbError());
  2029.     closeTransaction(pNdb);
  2030.     return NDBT_FAILED;
  2031.   }
  2032. }
  2033.       }
  2034.           
  2035.       // Define attributes to read  
  2036.       for(a = 0; a<tab.getNoOfColumns(); a++){
  2037. if((rows[b]->attributeStore(a) = 
  2038.     pOp->getValue(tab.getColumn(a)->getName())) == 0) {
  2039.   ERR(pTrans->getNdbError());
  2040.   closeTransaction(pNdb);
  2041.   return NDBT_FAILED;
  2042. }
  2043.       }
  2044.     }
  2045.     // NoCommit lockTime times with 100 millis interval
  2046.     int sleepInterval = 50;
  2047.     int lockCount = lockTime / sleepInterval;
  2048.     int commitCount = 0;
  2049.     do {
  2050.       check = pTrans->execute(NoCommit);   
  2051.       if( check == -1) {
  2052. const NdbError err = pTrans->getNdbError();
  2054. if (err.status == NdbError::TemporaryError){
  2055.   ERR(err);
  2056.   closeTransaction(pNdb);
  2057.   NdbSleep_MilliSleep(50);
  2058.   retryAttempt++;
  2059.   continue;
  2060. }
  2061. ERR(err);
  2062. closeTransaction(pNdb);
  2063. return NDBT_FAILED;
  2064.       }
  2065.       for (int b=0; (b<lockBatch) && (r+b<records); b++){ 
  2066. if (calc.verifyRowValues(rows[b]) != 0){
  2067.   closeTransaction(pNdb);
  2068.   return NDBT_FAILED;
  2069. }
  2070.       }
  2071.       commitCount++;
  2072.       NdbSleep_MilliSleep(sleepInterval);
  2073.     } while (commitCount < lockCount);
  2074.     
  2075.     // Really commit the trans, puuh!
  2076.     check = pTrans->execute(Commit);   
  2077.     if( check == -1) {
  2078.       const NdbError err = pTrans->getNdbError();
  2079.       
  2080.       if (err.status == NdbError::TemporaryError){
  2081. ERR(err);
  2082. closeTransaction(pNdb);
  2083. NdbSleep_MilliSleep(50);
  2084. retryAttempt++;
  2085. continue;
  2086.       }
  2087.       ERR(err);
  2088.       closeTransaction(pNdb);
  2089.       return NDBT_FAILED;
  2090.     }
  2091.     else{
  2092.       for (int b=0; (b<lockBatch) && (r<records); b++){ 
  2093. if (calc.verifyRowValues(rows[b]) != 0){
  2094.   closeTransaction(pNdb);
  2095.   return NDBT_FAILED;
  2096. }
  2097. r++; // Read next record
  2098.       }
  2099.     }
  2100.     
  2101.     closeTransaction(pNdb);
  2104.   }
  2105.   deallocRows();
  2106.   g_info << "|- Record locking completed" << endl;
  2107.   return NDBT_OK;
  2108. }
  2110. int 
  2111. HugoTransactions::indexReadRecords(Ndb* pNdb, 
  2112.    const char * idxName,
  2113.    int records,
  2114.    int batchsize){
  2115.   int                  reads = 0;
  2116.   int                  r = 0;
  2117.   int                  retryAttempt = 0;
  2118.   const int            retryMax = 100;
  2119.   int                  check, a;
  2120.   NdbOperation *pOp;
  2121.   NdbIndexScanOperation *sOp;
  2122.   NdbResultSet * rs;
  2124.   const NdbDictionary::Index* pIndex
  2125.     = pNdb->getDictionary()->getIndex(idxName, tab.getName());
  2126.   
  2127.   const bool ordered = (pIndex->getType()==NdbDictionary::Index::OrderedIndex);
  2129.   if (batchsize == 0) {
  2130.     g_info << "ERROR: Argument batchsize == 0 in indexReadRecords(). "
  2131.    << "Not allowed." << endl;
  2132.     return NDBT_FAILED;
  2133.   }
  2134.   
  2135.   if (ordered) {
  2136.     batchsize = 1;
  2137.   }
  2139.   allocRows(batchsize);
  2140.   
  2141.   while (r < records){
  2142.     if (retryAttempt >= retryMax){
  2143.       g_info << "ERROR: has retried this operation " << retryAttempt 
  2144.      << " times, failing!" << endl;
  2145.       return NDBT_FAILED;
  2146.     }
  2148.     pTrans = pNdb->startTransaction();
  2149.     if (pTrans == NULL) {
  2150.       const NdbError err = pNdb->getNdbError();
  2151.       
  2152.       if (err.status == NdbError::TemporaryError){
  2153. ERR(err);
  2154. NdbSleep_MilliSleep(50);
  2155. retryAttempt++;
  2156. continue;
  2157.       }
  2158.       ERR(err);
  2159.       return NDBT_FAILED;
  2160.     }
  2161.     
  2162.     for(int b=0; (b<batchsize) && (r+b < records); b++){
  2163.       if(!ordered){
  2164. pOp = pTrans->getNdbIndexOperation(idxName, tab.getName());
  2165. if (pOp == NULL) {
  2166.   ERR(pTrans->getNdbError());
  2167.   closeTransaction(pNdb);
  2168.   return NDBT_FAILED;
  2169. }
  2170. check = pOp->readTuple();
  2171.       } else {
  2172. pOp = sOp = pTrans->getNdbIndexScanOperation(idxName, tab.getName());
  2173. if (sOp == NULL) {
  2174.   ERR(pTrans->getNdbError());
  2175.   closeTransaction(pNdb);
  2176.   return NDBT_FAILED;
  2177. }
  2178.       
  2179. check = 0;
  2180. rs = sOp->readTuples();
  2181.       }
  2182.       
  2183.       if( check == -1 ) {
  2184. ERR(pTrans->getNdbError());
  2185. closeTransaction(pNdb);
  2186. return NDBT_FAILED;
  2187.       }
  2188.       
  2189.       // Define primary keys
  2190.       for(a = 0; a<tab.getNoOfColumns(); a++){
  2191. if (tab.getColumn(a)->getPrimaryKey() == true){
  2192.   if(equalForAttr(pOp, a, r+b) != 0){
  2193.     ERR(pTrans->getNdbError());
  2194.     closeTransaction(pNdb);
  2195.     return NDBT_FAILED;
  2196.   }
  2197. }
  2198.       }
  2199.       
  2200.       // Define attributes to read  
  2201.       for(a = 0; a<tab.getNoOfColumns(); a++){
  2202. if((rows[b]->attributeStore(a) = 
  2203.     pOp->getValue(tab.getColumn(a)->getName())) == 0) {
  2204.   ERR(pTrans->getNdbError());
  2205.   closeTransaction(pNdb);
  2206.   return NDBT_FAILED;
  2207. }
  2208.       }
  2209.     }
  2211.     check = pTrans->execute(Commit);   
  2212.     check = (check == -1 ? -1 : !ordered ? check : rs->nextResult(true));
  2213.     if( check == -1 ) {
  2214.       const NdbError err = pTrans->getNdbError();
  2215.       
  2216.       if (err.status == NdbError::TemporaryError){
  2217. ERR(err);
  2218. closeTransaction(pNdb);
  2219. NdbSleep_MilliSleep(50);
  2220. retryAttempt++;
  2221. continue;
  2222.       }
  2223.       switch(err.code){
  2224.       case 626: // Tuple did not exist
  2225.   g_info << r << ": " << err.code << " " << err.message << endl;
  2226.   r++;
  2227.   break;
  2228.   
  2229.       default:
  2230. ERR(err);
  2231. closeTransaction(pNdb);
  2232. return NDBT_FAILED;
  2233.       }
  2234.     } else{
  2235.       for (int b=0; (b<batchsize) && (r+b<records); b++){ 
  2236. if (calc.verifyRowValues(rows[b]) != 0){
  2237.   closeTransaction(pNdb);
  2238.   return NDBT_FAILED;
  2239. }
  2240. reads++;
  2241. r++;
  2242.       }
  2243.       if(ordered && rs->nextResult(true) == 0){
  2244. ndbout << "Error when comparing records "
  2245.        << " - index op next_result to many" << endl;
  2246. closeTransaction(pNdb);
  2247. return NDBT_FAILED;
  2248.       }
  2249.     }
  2250.     closeTransaction(pNdb);
  2251.   }
  2252.   deallocRows();
  2253.   g_info << reads << " records read" << endl;
  2254.   return NDBT_OK;
  2255. }
  2259. int 
  2260. HugoTransactions::indexUpdateRecords(Ndb* pNdb, 
  2261.      const char * idxName,
  2262.      int records,
  2263.      int batchsize){
  2265.   int updated = 0;
  2266.   int                  r = 0;
  2267.   int                  retryAttempt = 0;
  2268.   const int            retryMax = 100;
  2269.   int                  check, a, b;
  2270.   NdbOperation *pOp;
  2271.   NdbScanOperation * sOp;
  2272.   NdbResultSet * rs;
  2274.   const NdbDictionary::Index* pIndex
  2275.     = pNdb->getDictionary()->getIndex(idxName, tab.getName());
  2276.   
  2277.   const bool ordered = (pIndex->getType()==NdbDictionary::Index::OrderedIndex);
  2278.   if (ordered){
  2279.     batchsize = 1;
  2280.   }
  2282.   allocRows(batchsize);
  2283.   
  2284.   while (r < records){
  2285.     if (retryAttempt >= retryMax){
  2286.       g_info << "ERROR: has retried this operation " << retryAttempt 
  2287.      << " times, failing!" << endl;
  2288.       return NDBT_FAILED;
  2289.     }
  2290.     
  2291.     pTrans = pNdb->startTransaction();
  2292.     if (pTrans == NULL) {
  2293.       const NdbError err = pNdb->getNdbError();
  2294.       
  2295.       if (err.status == NdbError::TemporaryError){
  2296. ERR(err);
  2297. NdbSleep_MilliSleep(50);
  2298. retryAttempt++;
  2299. continue;
  2300.       }
  2301.       ERR(err);
  2302.       return NDBT_FAILED;
  2303.     }
  2305.     for(b = 0; b<batchsize && (b+r)<records; b++){
  2306.       if(!ordered){
  2307. pOp = pTrans->getNdbIndexOperation(idxName, tab.getName());
  2308. if (pOp == NULL) {
  2309.   ERR(pTrans->getNdbError());
  2310.   closeTransaction(pNdb);
  2311.   return NDBT_FAILED;
  2312. }
  2314. check = pOp->readTupleExclusive();
  2315. if( check == -1 ) {
  2316.   ERR(pTrans->getNdbError());
  2317.   closeTransaction(pNdb);
  2318.   return NDBT_FAILED;
  2319. }
  2320.       } else {
  2321. pOp = sOp = pTrans->getNdbIndexScanOperation(idxName, tab.getName());
  2322. if (pOp == NULL) {
  2323.   ERR(pTrans->getNdbError());
  2324.   closeTransaction(pNdb);
  2325.   return NDBT_FAILED;
  2326. }
  2328. check = 0;
  2329. rs = sOp->readTuplesExclusive();
  2330.       }
  2331.       
  2332.       // Define primary keys
  2333.       for(a = 0; a<tab.getNoOfColumns(); a++){
  2334. if (tab.getColumn(a)->getPrimaryKey() == true){
  2335.   if(equalForAttr(pOp, a, r+b) != 0){
  2336.     ERR(pTrans->getNdbError());
  2337.     closeTransaction(pNdb);
  2338.     return NDBT_FAILED;
  2339.   }
  2340. }
  2341.       }
  2342.       
  2343.       // Define attributes to read  
  2344.       for(a = 0; a<tab.getNoOfColumns(); a++){
  2345. if((rows[b]->attributeStore(a) = 
  2346.     pOp->getValue(tab.getColumn(a)->getName())) == 0) {
  2347.   ERR(pTrans->getNdbError());
  2348.   closeTransaction(pNdb);
  2349.   return NDBT_FAILED;
  2350. }
  2351.       }
  2352.     }
  2353.      
  2354.     check = pTrans->execute(NoCommit);   
  2355.     check = (check == -1 ? -1 : !ordered ? check : rs->nextResult(true));
  2356.     if( check == -1 ) {
  2357.       const NdbError err = pTrans->getNdbError();
  2358.       ERR(err);
  2359.       closeTransaction(pNdb);
  2360.       
  2361.       if (err.status == NdbError::TemporaryError){
  2362. NdbSleep_MilliSleep(50);
  2363. retryAttempt++;
  2364. continue;
  2365.       }
  2366.       return NDBT_FAILED;
  2367.     }
  2369.     if(ordered && check != 0){
  2370.       g_err << "Row: " << r << " not found!!" << endl;
  2371.       closeTransaction(pNdb);
  2372.       return NDBT_FAILED;    
  2373.     }
  2374.     
  2375.     for(b = 0; b<batchsize && (b+r)<records; b++){
  2376.       if (calc.verifyRowValues(rows[b]) != 0){
  2377. closeTransaction(pNdb);
  2378. return NDBT_FAILED;
  2379.       }
  2380.       
  2381.       int updates = calc.getUpdatesValue(rows[b]) + 1;
  2382.       
  2383.       NdbOperation* pUpdOp;
  2384.       if(!ordered){
  2385. pUpdOp = pTrans->getNdbIndexOperation(idxName, tab.getName());
  2386. check = (pUpdOp == 0 ? -1 : pUpdOp->updateTuple());
  2387.       } else {
  2388. pUpdOp = rs->updateTuple();
  2389.       }
  2391.       if (pUpdOp == NULL) {
  2392. ERR(pTrans->getNdbError());
  2393. closeTransaction(pNdb);
  2394. return NDBT_FAILED;
  2395.       }
  2396.       
  2397.       if( check == -1 ) {
  2398. ERR(pTrans->getNdbError());
  2399. closeTransaction(pNdb);
  2400. return NDBT_FAILED;
  2401.       }
  2402.       
  2403.       if(!ordered){
  2404. for(a = 0; a<tab.getNoOfColumns(); a++){
  2405.   if (tab.getColumn(a)->getPrimaryKey() == true){
  2406.     if(equalForAttr(pUpdOp, a, r+b) != 0){
  2407.       ERR(pTrans->getNdbError());
  2408.       closeTransaction(pNdb);
  2409.       return NDBT_FAILED;
  2410.     }
  2411.   }
  2412. }
  2413.       }
  2414.       
  2415.       for(a = 0; a<tab.getNoOfColumns(); a++){
  2416. if (tab.getColumn(a)->getPrimaryKey() == false){
  2417.   if(setValueForAttr(pUpdOp, a, r+b, updates ) != 0){
  2418.     ERR(pTrans->getNdbError());
  2419.     closeTransaction(pNdb);
  2420.     return NDBT_FAILED;
  2421.   }
  2422. }
  2423.       }
  2424.     }
  2425.     
  2426.     check = pTrans->execute(Commit);   
  2427.     if( check == -1 ) {
  2428.       const NdbError err = pTrans->getNdbError();
  2429.       ERR(err);
  2430.       closeTransaction(pNdb);
  2431.       
  2432.       if (err.status == NdbError::TemporaryError){
  2433. NdbSleep_MilliSleep(50);
  2434. retryAttempt++;
  2435. continue;
  2436.       }
  2437.       ndbout << "r = " << r << endl;
  2438.       return NDBT_FAILED;
  2439.     } else {
  2440.       updated += batchsize;
  2441.     }
  2442.     
  2443.     closeTransaction(pNdb);
  2444.     
  2445.     r+= batchsize; // Read next record
  2446.   }
  2447.   
  2448.   g_info << "|- " << updated << " records updated" << endl;
  2449.   return NDBT_OK;
  2450. }
  2452. template class Vector<NDBT_ResultRow*>;