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

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

MySQL数据库

开发平台：

Visual C++

UtilTransactions.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 "UtilTransactions.hpp"
  18. #include <NdbSleep.h>
  19. #include <NdbScanFilter.hpp>
  21. #define VERBOSE 0
  23. UtilTransactions::UtilTransactions(const NdbDictionary::Table& _tab):
  24.   tab(_tab){
  25.   m_defaultClearMethod = 3;
  26. }
  28. UtilTransactions::UtilTransactions(Ndb* ndb, const char * name) :
  29.   tab(* ndb->getDictionary()->getTable(name)){
  30.   m_defaultClearMethod = 3;
  31. }
  33. #define RESTART_SCAN 99
  35. #define RETURN_FAIL(err) return (err.code != 0 ? err.code : NDBT_FAILED) 
  37. int 
  38. UtilTransactions::clearTable(Ndb* pNdb, 
  39.      int records,
  40.      int parallelism){
  41.   if(m_defaultClearMethod == 1){
  42.     return clearTable1(pNdb, records, parallelism);
  43.   } else if(m_defaultClearMethod == 2){
  44.     return clearTable2(pNdb, records, parallelism);
  45.   } else {
  46.     return clearTable3(pNdb, records, parallelism);
  47.   }
  48. }
  51. int 
  52. UtilTransactions::clearTable1(Ndb* pNdb, 
  53.      int records,
  54.      int parallelism){
  55. #if 1
  56.   return clearTable3(pNdb, records, 1);
  57. #else
  58.   // Scan all records exclusive and delete 
  59.   // them one by one
  60.   int                  retryAttempt = 0;
  61.   const int            retryMax = 100;
  62.   int check;
  63.   NdbConnection *pTrans;
  64.   NdbOperation *pOp;
  66.   while (true){
  68.     if (retryAttempt >= retryMax){
  69.       g_info << "ERROR: Has retried this operation " << retryAttempt
  70.      << " times, failing!" << endl;
  71.       return NDBT_FAILED;
  72.     }
  75.     pTrans = pNdb->startTransaction();
  76.     if (pTrans == NULL) {
  77.       NdbError err = pNdb->getNdbError();
  79.       if (err.status == NdbError::TemporaryError){
  80. ERR(err);
  81. NdbSleep_MilliSleep(50);
  82. retryAttempt++;
  83. continue;
  84.       }
  85.       ERR(err);
  86.       RETURN_FAIL(err);
  87.     }
  89.     pOp = pTrans->getNdbOperation(tab.getName());
  90.     if (pOp == NULL) {
  91.       NdbError err = pNdb->getNdbError();
  92.       ERR(err);
  93.       pNdb->closeTransaction(pTrans);
  94.       RETURN_FAIL(err);
  95.     }
  97.     check = pOp->openScanExclusive(parallelism);
  98.     if( check == -1 ) {
  99.       NdbError err = pNdb->getNdbError();
  100.       ERR(pTrans->getNdbError());
  101.       pNdb->closeTransaction(pTrans);
  102.       RETURN_FAIL(err);
  103.     }
  105.     check = pOp->interpret_exit_ok();
  106.     if( check == -1 ) {
  107.       NdbError err = pNdb->getNdbError();
  108.       ERR(pTrans->getNdbError());
  109.       pNdb->closeTransaction(pTrans);
  110.       RETURN_FAIL(err);
  111.     }  
  112. #if 0
  113.     // It's not necessary to read and PK's
  114.     // Information about the PK's are sent in
  115.     // KEYINFO20 signals anyway and used by takeOverScan
  117.     // Read the primary keys from this table    
  118.     for(int a=0; a<tab.getNoOfColumns(); a++){
  119.       if (tab.getColumn(a)->getPrimaryKey()){
  120. if(pOp->getValue(tab.getColumn(a)->getName()) == NULL){
  121.   ERR(pTrans->getNdbError());
  122.   pNdb->closeTransaction(pTrans);
  123.   RETURN_FAIL(err);
  124. }
  125.       }
  126.     }
  127. #endif
  129.     check = pTrans->executeScan();   
  130.     if( check == -1 ) {
  131.       NdbError err = pTrans->getNdbError();
  133.       if (err.status == NdbError::TemporaryError){
  134. ERR(err);
  135. pNdb->closeTransaction(pTrans);
  136. NdbSleep_MilliSleep(50);
  137. retryAttempt++;
  138. continue;
  139.       }
  140.       ERR(err);
  141.       pNdb->closeTransaction(pTrans);
  142.       RETURN_FAIL(err);
  143.     }
  144.   
  145.     int eof;
  146.     int rows = 0;
  148.     eof = pTrans->nextScanResult();
  149.     while(eof == 0){
  150.       rows++;
  152.       int res = takeOverAndDeleteRecord(pNdb, pOp);
  153.       if(res == RESTART_SCAN){
  154. eof = -2;
  155. continue;
  156.       }
  158.       if (res != 0){      
  159. NdbError err = pNdb->getNdbError(res);
  160. pNdb->closeTransaction(pTrans);
  161. RETURN_FAIL(err);
  162.       }
  163.       
  164.       eof = pTrans->nextScanResult();
  165.     }
  166.   
  167.     if (eof == -1) {
  168.       const NdbError err = pTrans->getNdbError();
  170.       if (err.status == NdbError::TemporaryError){
  171. ERR(err);
  172. pNdb->closeTransaction(pTrans);
  173. NdbSleep_MilliSleep(50);
  174. // If error = 488 there should be no limit on number of retry attempts
  175. if (err.code != 488) 
  176.   retryAttempt++;
  177. continue;
  178.       }
  179.       ERR(err);
  180.       pNdb->closeTransaction(pTrans);
  181.       RETURN_FAIL(err);
  182.     }
  184.     if(eof == -2){
  185.       pNdb->closeTransaction(pTrans);
  186.       NdbSleep_MilliSleep(50);
  187.       retryAttempt++;
  188.       continue;
  189.     }
  190.     
  191.     pNdb->closeTransaction(pTrans);
  193.     g_info << rows << " deleted" << endl;
  195.     return NDBT_OK;
  196.   }
  197.   return NDBT_FAILED;
  198. #endif
  199. }
  201. int 
  202. UtilTransactions::clearTable2(Ndb* pNdb, 
  203.      int records,
  204.      int parallelism){
  205. #if 1
  206.   return clearTable3(pNdb, records, parallelism);
  207. #else
  208.   // Scan all records exclusive and delete 
  209.   // them one by one
  210.   int                  retryAttempt = 0;
  211.   const int            retryMax = 10;
  212.   int deletedRows = 0;
  213.   int check;
  214.   NdbConnection *pTrans;
  215.   NdbOperation *pOp;
  217.   while (true){
  219.     if (retryAttempt >= retryMax){
  220.       g_info << "ERROR: has retried this operation " << retryAttempt 
  221.      << " times, failing!" << endl;
  222.       return NDBT_FAILED;
  223.     }
  226.     pTrans = pNdb->startTransaction();
  227.     if (pTrans == NULL) {
  228.       const NdbError err = pNdb->getNdbError();
  230.       if (err.status == NdbError::TemporaryError){
  231. ERR(err);
  232. NdbSleep_MilliSleep(50);
  233. retryAttempt++;
  234. continue;
  235.       }
  236.       ERR(err);
  237.       return NDBT_FAILED;
  238.     }
  240.     pOp = pTrans->getNdbOperation(tab.getName());
  241.     if (pOp == NULL) {
  242.       ERR(pTrans->getNdbError());
  243.       pNdb->closeTransaction(pTrans);
  244.       return NDBT_FAILED;
  245.     }
  247.     check = pOp->openScanExclusive(parallelism);
  248.     if( check == -1 ) {
  249.       ERR(pTrans->getNdbError());
  250.       pNdb->closeTransaction(pTrans);
  251.       return NDBT_FAILED;
  252.     }
  254.     check = pOp->interpret_exit_ok();
  255.     if( check == -1 ) {
  256.       ERR(pTrans->getNdbError());
  257.       pNdb->closeTransaction(pTrans);
  258.       return NDBT_FAILED;
  259.     }  
  260. #if 0
  261.     // It's not necessary to read any PK's
  262.     // Information about the PK's are sent in
  263.     // KEYINFO20 signals anyway and used by takeOverScan
  265.     // Read the primary keys from this table    
  266.     for(int a=0; a<tab.getNoOfColumns(); a++){
  267.       if (tab.getColumn(a)->getPrimaryKey()){
  268. if(pOp->getValue(tab.getColumn(a)->getName()) == NULL){
  269.   ERR(pTrans->getNdbError());
  270.   pNdb->closeTransaction(pTrans);
  271.   return -1;
  272. }
  273.       }
  274.     }
  275. #endif
  277.     check = pTrans->executeScan();   
  278.     if( check == -1 ) {
  279.       ERR(pTrans->getNdbError());
  280.       pNdb->closeTransaction(pTrans);
  281.       return NDBT_FAILED;
  282.     }
  283.   
  284.     int eof;
  285.     NdbConnection* pDelTrans;
  287.     while((eof = pTrans->nextScanResult(true)) == 0){
  288.       pDelTrans = pNdb->startTransaction();
  289.       if (pDelTrans == NULL) {
  290. const NdbError err = pNdb->getNdbError();
  291. #if 0
  292. if (err.status == NdbError::TemporaryError){
  293.   ERR(err);
  294.   NdbSleep_MilliSleep(50);
  295.   retryAttempt++;
  296.   continue;
  297. }
  298. #endif
  299. ERR(err);
  300. pNdb->closeTransaction(pDelTrans);
  301. return NDBT_FAILED;
  302.       }
  303.       do {
  304. deletedRows++;
  305. if (addRowToDelete(pNdb, pDelTrans, pOp) != 0){
  306.   pNdb->closeTransaction(pDelTrans);
  307.   pNdb->closeTransaction(pTrans);
  308.   return NDBT_FAILED;
  309. }
  310.       } while((eof = pTrans->nextScanResult(false)) == 0);
  312.       check = pDelTrans->execute(Commit);   
  313.       if( check == -1 ) {
  314. const NdbError err = pDelTrans->getNdbError();    
  315. ERR(err);
  316. pNdb->closeTransaction(pDelTrans);
  317. pNdb->closeTransaction(pTrans);
  318. return NDBT_FAILED;
  319.       }
  320.       pNdb->closeTransaction(pDelTrans);
  322.     }  
  323.     if (eof == -1) {
  324.       const NdbError err = pTrans->getNdbError();
  326.       if (err.status == NdbError::TemporaryError){
  327. ERR(err);
  328. pNdb->closeTransaction(pTrans);
  329. NdbSleep_MilliSleep(50);
  330. // If error = 488 there should be no limit on number of retry attempts
  331. if (err.code != 488) 
  332.   retryAttempt++;
  333. continue;
  334.       }
  335.       ERR(err);
  336.       pNdb->closeTransaction(pTrans);
  337.       return NDBT_FAILED;
  338.     }
  340.     pNdb->closeTransaction(pTrans);
  342.     g_info << deletedRows << " rows deleted" << endl;
  344.     return NDBT_OK;
  345.   }
  346.   return NDBT_FAILED;
  347. #endif
  348. }
  350. int 
  351. UtilTransactions::clearTable3(Ndb* pNdb, 
  352.      int records,
  353.      int parallelism){
  354.   // Scan all records exclusive and delete 
  355.   // them one by one
  356.   int                  retryAttempt = 0;
  357.   const int            retryMax = 10;
  358.   int deletedRows = 0;
  359.   int check;
  360.   NdbConnection *pTrans;
  361.   NdbScanOperation *pOp;
  362.   NdbError err;
  364.   int par = parallelism;
  365.   while (true){
  366.   restart:
  367.     if (retryAttempt++ >= retryMax){
  368.       g_info << "ERROR: has retried this operation " << retryAttempt 
  369.      << " times, failing!" << endl;
  370.       return NDBT_FAILED;
  371.     }
  372.     
  373.     pTrans = pNdb->startTransaction();
  374.     if (pTrans == NULL) {
  375.       err = pNdb->getNdbError();
  376.       if (err.status == NdbError::TemporaryError){
  377. ERR(err);
  378. NdbSleep_MilliSleep(50);
  379. continue;
  380.       }
  381.       goto failed;
  382.     }
  383.     
  384.     pOp = pTrans->getNdbScanOperation(tab.getName());
  385.     if (pOp == NULL) {
  386.       err = pTrans->getNdbError();
  387.       if(err.status == NdbError::TemporaryError){
  388. ERR(err);
  389. pNdb->closeTransaction(pTrans);
  390. NdbSleep_MilliSleep(50);
  391. par = 1;
  392. goto restart;
  393.       }
  394.       goto failed;
  395.     }
  396.     
  397.     NdbResultSet * rs = pOp->readTuplesExclusive(par);
  398.     if( rs == 0 ) {
  399.       err = pTrans->getNdbError();
  400.       goto failed;
  401.     }
  402.     
  403.     if(pTrans->execute(NoCommit) != 0){
  404.       err = pTrans->getNdbError();    
  405.       if(err.status == NdbError::TemporaryError){
  406. ERR(err);
  407. pNdb->closeTransaction(pTrans);
  408. NdbSleep_MilliSleep(50);
  409. continue;
  410.       }
  411.       goto failed;
  412.     }
  413.     
  414.     while((check = rs->nextResult(true)) == 0){
  415.       do {
  416. if (rs->deleteTuple() != 0){
  417.   goto failed;
  418. }
  419. deletedRows++;
  420.       } while((check = rs->nextResult(false)) == 0);
  421.       
  422.       if(check != -1){
  423. check = pTrans->execute(Commit);   
  424. pTrans->restart();
  425.       }
  426.       
  427.       err = pTrans->getNdbError();    
  428.       if(check == -1){
  429. if(err.status == NdbError::TemporaryError){
  430.   ERR(err);
  431.   pNdb->closeTransaction(pTrans);
  432.   NdbSleep_MilliSleep(50);
  433.   par = 1;
  434.   goto restart;
  435. }
  436. goto failed;
  437.       }
  438.     }
  439.     if(check == -1){
  440.       err = pTrans->getNdbError();    
  441.       if(err.status == NdbError::TemporaryError){
  442. ERR(err);
  443. pNdb->closeTransaction(pTrans);
  444. NdbSleep_MilliSleep(50);
  445. par = 1;
  446. goto restart;
  447.       }
  448.       goto failed;
  449.     }
  450.     pNdb->closeTransaction(pTrans);
  451.     return NDBT_OK;
  452.   }
  453.   return NDBT_FAILED;
  454.   
  455.  failed:
  456.   if(pTrans != 0) pNdb->closeTransaction(pTrans);
  457.   ERR(err);
  458.   return (err.code != 0 ? err.code : NDBT_FAILED);
  459. }
  461. int 
  462. UtilTransactions::copyTableData(Ndb* pNdb,
  463.     const char* destName){
  464.   // Scan all records and copy 
  465.   // them to destName table
  466.   int                  retryAttempt = 0;
  467.   const int            retryMax = 10;
  468.   int insertedRows = 0;
  469.   int parallelism = 240;
  470.   int check;
  471.   NdbConnection *pTrans;
  472.   NdbScanOperation *pOp;
  473.   NDBT_ResultRow       row(tab);
  474.   
  475.   while (true){
  476.     
  477.     if (retryAttempt >= retryMax){
  478.       g_info << "ERROR: has retried this operation " << retryAttempt 
  479.      << " times, failing!" << endl;
  480.       return NDBT_FAILED;
  481.     }
  484.     pTrans = pNdb->startTransaction();
  485.     if (pTrans == NULL) {
  486.       const NdbError err = pNdb->getNdbError();
  488.       if (err.status == NdbError::TemporaryError){
  489. ERR(err);
  490. NdbSleep_MilliSleep(50);
  491. retryAttempt++;
  492. continue;
  493.       }
  494.       ERR(err);
  495.       return NDBT_FAILED;
  496.     }
  498.     pOp = pTrans->getNdbScanOperation(tab.getName());
  499.     if (pOp == NULL) {
  500.       ERR(pTrans->getNdbError());
  501.       pNdb->closeTransaction(pTrans);
  502.       return NDBT_FAILED;
  503.     }
  505.     NdbResultSet* rs = pOp->readTuples(NdbScanOperation::LM_Read, 
  506.        parallelism);
  507.     if( check == -1 ) {
  508.       ERR(pTrans->getNdbError());
  509.       pNdb->closeTransaction(pTrans);
  510.       return NDBT_FAILED;
  511.     }
  513.     check = pOp->interpret_exit_ok();
  514.     if( check == -1 ) {
  515.       ERR(pTrans->getNdbError());
  516.       pNdb->closeTransaction(pTrans);
  517.       return NDBT_FAILED;
  518.     }  
  520.     // Read all attributes
  521.     for (int a = 0; a < tab.getNoOfColumns(); a++){
  522.       if ((row.attributeStore(a) =  
  523.    pOp->getValue(tab.getColumn(a)->getName())) == 0) {
  524. ERR(pTrans->getNdbError());
  525. pNdb->closeTransaction(pTrans);
  526. return NDBT_FAILED;
  527.       }
  528.     }
  529.     
  530.     check = pTrans->execute(NoCommit);
  531.     if( check == -1 ) {
  532.       ERR(pTrans->getNdbError());
  533.       pNdb->closeTransaction(pTrans);
  534.       return NDBT_FAILED;
  535.     }
  536.   
  537.     int eof;
  538.     while((eof = rs->nextResult(true)) == 0){
  539.       do {
  540. insertedRows++;
  541. if (addRowToInsert(pNdb, pTrans, row, destName) != 0){
  542.   pNdb->closeTransaction(pTrans);
  543.   return NDBT_FAILED;
  544. }
  545.       } while((eof = rs->nextResult(false)) == 0);
  546.       
  547.       check = pTrans->execute(Commit);   
  548.       pTrans->restart();
  549.       if( check == -1 ) {
  550. const NdbError err = pTrans->getNdbError();    
  551. ERR(err);
  552. pNdb->closeTransaction(pTrans);
  553. return NDBT_FAILED;
  554.       }
  555.     }  
  556.     if (eof == -1) {
  557.       const NdbError err = pTrans->getNdbError();
  558.       
  559.       if (err.status == NdbError::TemporaryError){
  560. ERR(err);
  561. pNdb->closeTransaction(pTrans);
  562. NdbSleep_MilliSleep(50);
  563. // If error = 488 there should be no limit on number of retry attempts
  564. if (err.code != 488) 
  565.   retryAttempt++;
  566. continue;
  567.       }
  568.       ERR(err);
  569.       pNdb->closeTransaction(pTrans);
  570.       return NDBT_FAILED;
  571.     }
  572.     
  573.     pNdb->closeTransaction(pTrans);
  574.     
  575.     g_info << insertedRows << " rows copied" << endl;
  576.     
  577.     return NDBT_OK;
  578.   }
  579.   return NDBT_FAILED;
  580. }
  582. int 
  583. UtilTransactions::addRowToInsert(Ndb* pNdb,
  584.  NdbConnection* pInsTrans,
  585.  NDBT_ResultRow & row,
  586.  const char *insertTabName){
  588.   int check;
  589.   NdbOperation* pInsOp;
  591.   pInsOp = pInsTrans->getNdbOperation(insertTabName);
  592.   if (pInsOp == NULL) {
  593.     ERR(pInsTrans->getNdbError());
  594.     return NDBT_FAILED;
  595.   }
  596.   
  597.   check = pInsOp->insertTuple();
  598.   if( check == -1 ) {
  599.     ERR(pInsTrans->getNdbError());
  600.     return NDBT_FAILED;
  601.   }
  603.   // Set all attributes
  604.   for (int a = 0; a < tab.getNoOfColumns(); a++){
  605.     NdbRecAttr* r =  row.attributeStore(a);
  606.     int  sz = r->attrSize() * r->arraySize();
  607.     if (pInsOp->setValue(tab.getColumn(a)->getName(),
  608.  r->aRef(),
  609.  sz) != 0) {
  610.       ERR(pInsTrans->getNdbError());
  611.       return NDBT_FAILED;
  612.     }
  613.   }
  614.   
  615.   return NDBT_OK;
  616. }
  619. int 
  620. UtilTransactions::scanReadRecords(Ndb* pNdb,
  621.   int parallelism,
  622.   NdbOperation::LockMode lm,
  623.   int records,
  624.   int noAttribs,
  625.   int *attrib_list,
  626.   ReadCallBackFn* fn){
  627.   
  628.   int                  retryAttempt = 0;
  629.   const int            retryMax = 100;
  630.   int                  check;
  631.   NdbConnection        *pTrans;
  632.   NdbScanOperation        *pOp;
  633.   NDBT_ResultRow       row(tab);
  635.   while (true){
  637.     if (retryAttempt >= retryMax){
  638.       g_info << "ERROR: has retried this operation " << retryAttempt 
  639.      << " times, failing!" << endl;
  640.       return NDBT_FAILED;
  641.     }
  643.     pTrans = pNdb->startTransaction();
  644.     if (pTrans == NULL) {
  645.       const NdbError err = pNdb->getNdbError();
  647.       if (err.status == NdbError::TemporaryError){
  648. ERR(err);
  649. NdbSleep_MilliSleep(50);
  650. retryAttempt++;
  651. continue;
  652.       }
  653.       ERR(err);
  654.       return NDBT_FAILED;
  655.     }
  657.     pOp = pTrans->getNdbScanOperation(tab.getName());
  658.     if (pOp == NULL) {
  659.       const NdbError err = pNdb->getNdbError();
  660.       pNdb->closeTransaction(pTrans);
  662.       if (err.status == NdbError::TemporaryError){
  663. ERR(err);
  664. NdbSleep_MilliSleep(50);
  665. retryAttempt++;
  666. continue;
  667.       }
  668.       ERR(err);
  669.       return NDBT_FAILED;
  670.     }
  672.     NdbResultSet * rs = pOp->readTuples(lm, 0, parallelism);
  673.     if( rs == 0 ) {
  674.       ERR(pTrans->getNdbError());
  675.       pNdb->closeTransaction(pTrans);
  676.       return NDBT_FAILED;
  677.     }
  679.     check = pOp->interpret_exit_ok();
  680.     if( check == -1 ) {
  681.       ERR(pTrans->getNdbError());
  682.       pNdb->closeTransaction(pTrans);
  683.       return NDBT_FAILED;
  684.     }
  685.     
  686.     // Call getValue for all the attributes supplied in attrib_list
  687.     // ************************************************
  688.     for (int a = 0; a < noAttribs; a++){
  689.       if (attrib_list[a] < tab.getNoOfColumns()){ 
  690. g_info << "getValue(" << attrib_list[a] << ")" << endl;
  691. if ((row.attributeStore(attrib_list[a]) =  
  692.      pOp->getValue(tab.getColumn(attrib_list[a])->getName())) == 0) {
  693.   ERR(pTrans->getNdbError());
  694.   pNdb->closeTransaction(pTrans);
  695.   return NDBT_FAILED;
  696. }
  697.       }
  698.     }
  699.     // *************************************************
  700.     
  701.     check = pTrans->execute(NoCommit);
  702.     if( check == -1 ) {
  703.       const NdbError err = pTrans->getNdbError();
  705.       if (err.status == NdbError::TemporaryError){
  706. ERR(err);
  707. pNdb->closeTransaction(pTrans);
  708. NdbSleep_MilliSleep(50);
  709. retryAttempt++;
  710. continue;
  711.       }
  712.       ERR(err);
  713.       pNdb->closeTransaction(pTrans);
  714.       return NDBT_FAILED;
  715.     }
  716.     
  717.     int eof;
  718.     int rows = 0;
  719.     
  720.     
  721.     while((eof = rs->nextResult()) == 0){
  722.       rows++;
  723.       
  724.       // Call callback for each record returned
  725.       if(fn != NULL)
  726. fn(&row);
  727.     }
  728.     if (eof == -1) {
  729.       const NdbError err = pTrans->getNdbError();
  730.       
  731.       if (err.status == NdbError::TemporaryError){
  732. ERR(err);
  733. pNdb->closeTransaction(pTrans);
  734. NdbSleep_MilliSleep(50);
  735. retryAttempt++;
  736. continue;
  737.       }
  738.       ERR(err);
  739.       pNdb->closeTransaction(pTrans);
  740.       return NDBT_FAILED;
  741.     }
  742.     
  743.     pNdb->closeTransaction(pTrans);
  744.     g_info << rows << " rows have been read" << endl;
  745.     if (records != 0 && rows != records){
  746.       g_info << "Check expected number of records failed" << endl 
  747.      << "  expected=" << records <<", " << endl
  748.      << "  read=" << rows << endl;
  749.       return NDBT_FAILED;
  750.     }
  751.     
  752.     return NDBT_OK;
  753.   }
  754.   return NDBT_FAILED;
  755. }
  757. int 
  758. UtilTransactions::selectCount(Ndb* pNdb, 
  759.       int parallelism,
  760.       int* count_rows,
  761.       NdbOperation::LockMode lm,
  762.       NdbConnection* pTrans){
  763.   
  764.   int                  retryAttempt = 0;
  765.   const int            retryMax = 100;
  766.   int                  check;
  767.   NdbScanOperation     *pOp;
  769.   while (true){
  770.     if (retryAttempt >= retryMax){
  771.       g_info << "ERROR: has retried this operation " << retryAttempt 
  772.      << " times, failing!" << endl;
  773.       return NDBT_FAILED;
  774.     }
  775.     if(!pTrans)
  776.       pTrans = pNdb->startTransaction();
  777.     
  778.     if(!pTrans)
  779.     {
  780.       const NdbError err = pNdb->getNdbError();
  781.       
  782.       if (err.status == NdbError::TemporaryError)
  783. continue;
  784.       return NDBT_FAILED;
  785.     }
  786.     
  787.     pOp = pTrans->getNdbScanOperation(tab.getName());
  788.     if (pOp == NULL) {
  789.       ERR(pTrans->getNdbError());
  790.       pNdb->closeTransaction(pTrans);
  791.       pTrans = 0;
  792.       return NDBT_FAILED;
  793.     }
  795.     NdbResultSet * rs = pOp->readTuples(lm);
  796.     if( rs == 0) {
  797.       ERR(pTrans->getNdbError());
  798.       pNdb->closeTransaction(pTrans);
  799.       pTrans = 0;
  800.       return NDBT_FAILED;
  801.     }
  803.     if(0){
  804.       NdbScanFilter sf(pOp);
  805.       sf.begin(NdbScanFilter::OR);
  806.       sf.eq(2, (Uint32)30);
  807.       sf.end();
  808.     } else {
  809.       check = pOp->interpret_exit_ok();
  810.       if( check == -1 ) {
  811. ERR(pTrans->getNdbError());
  812. pNdb->closeTransaction(pTrans);
  813. pTrans = 0;
  814. return NDBT_FAILED;
  815.       }
  816.     }
  817.     
  818.     
  819.     check = pTrans->execute(NoCommit);
  820.     if( check == -1 ) {
  821.       ERR(pTrans->getNdbError());
  822.       pNdb->closeTransaction(pTrans);
  823.       pTrans = 0;
  824.       return NDBT_FAILED;
  825.     }
  827.     int eof;
  828.     int rows = 0;
  829.     
  831.     while((eof = rs->nextResult()) == 0){
  832.       rows++;
  833.     }
  834.     if (eof == -1) {
  835.       const NdbError err = pTrans->getNdbError();
  836.       
  837.       if (err.status == NdbError::TemporaryError){
  838. pNdb->closeTransaction(pTrans);
  839. pTrans = 0;
  840. NdbSleep_MilliSleep(50);
  841. retryAttempt++;
  842. continue;
  843.       }
  844.       ERR(err);
  845.       pNdb->closeTransaction(pTrans);
  846.       pTrans = 0;
  847.       return NDBT_FAILED;
  848.     }
  849.     
  850.     pNdb->closeTransaction(pTrans);
  851.     pTrans = 0;
  852.     
  853.     if (count_rows != NULL){
  854.       *count_rows = rows;
  855.     }
  856.     
  857.     return NDBT_OK;
  858.   }
  859.   return NDBT_FAILED;
  860. }
  861.   
  862. int 
  863. UtilTransactions::verifyIndex(Ndb* pNdb,
  864.       const char* indexName,
  865.       int parallelism,
  866.       bool transactional){
  867.   
  869.   const NdbDictionary::Index* pIndex
  870.     = pNdb->getDictionary()->getIndex(indexName, tab.getName());
  871.   if (pIndex == 0){
  872.     ndbout << " Index " << indexName << " does not exist!" << endl;
  873.     return NDBT_FAILED;
  874.   }
  875.   
  876.   switch (pIndex->getType()){
  877.   case NdbDictionary::Index::UniqueHashIndex:
  878.     return verifyUniqueIndex(pNdb, pIndex, parallelism, transactional);
  879.   case NdbDictionary::Index::OrderedIndex:
  880.     return verifyOrderedIndex(pNdb, pIndex, parallelism, transactional);
  881.     break;
  882.   default:
  883.     ndbout << "Unknown index type" << endl;
  884.     break;
  885.   }
  886.   
  887.   return NDBT_FAILED;
  888. }
  890. int 
  891. UtilTransactions::verifyUniqueIndex(Ndb* pNdb,
  892.     const NdbDictionary::Index * pIndex,
  893.     int parallelism,
  894.     bool transactional){
  895.   
  896.   /**
  897.    * Scan all rows in TABLE and for each found row make one read in
  898.    * TABLE and one using INDEX_TABLE. Then compare the two returned 
  899.    * rows. They should be equal!
  900.    *
  901.    */
  903.   if (scanAndCompareUniqueIndex(pNdb, 
  904. pIndex,
  905. parallelism,
  906. transactional) != NDBT_OK){
  907.     return NDBT_FAILED;
  908.   }
  911.   return NDBT_OK;
  912.   
  913. }
  916. int 
  917. UtilTransactions::scanAndCompareUniqueIndex(Ndb* pNdb,
  918.     const NdbDictionary::Index* pIndex,
  919.     int parallelism,
  920.     bool transactional){
  921.   
  922.   int                  retryAttempt = 0;
  923.   const int            retryMax = 100;
  924.   int                  check;
  925.   NdbConnection        *pTrans;
  926.   NdbScanOperation       *pOp;
  927.   NDBT_ResultRow       row(tab);
  929.   parallelism = 1;
  931.   while (true){
  933.     if (retryAttempt >= retryMax){
  934.       g_info << "ERROR: has retried this operation " << retryAttempt 
  935.      << " times, failing!" << endl;
  936.       return NDBT_FAILED;
  937.     }
  939.     pTrans = pNdb->startTransaction();
  940.     if (pTrans == NULL) {
  941.       const NdbError err = pNdb->getNdbError();
  943.       if (err.status == NdbError::TemporaryError){
  944. ERR(err);
  945. NdbSleep_MilliSleep(50);
  946. retryAttempt++;
  947. continue;
  948.       }
  949.       ERR(err);
  950.       return NDBT_FAILED;
  951.     }
  953.     pOp = pTrans->getNdbScanOperation(tab.getName());
  954.     if (pOp == NULL) {
  955.       const NdbError err = pNdb->getNdbError();
  956.       pNdb->closeTransaction(pTrans);
  957.       ERR(err);
  958.       
  959.       if (err.status == NdbError::TemporaryError){
  960. NdbSleep_MilliSleep(50);
  961. retryAttempt++;
  962. continue;
  963.       }
  964.       return NDBT_FAILED;
  965.     }
  967.     NdbResultSet* rs;
  968.     if(transactional){
  969.       rs = pOp->readTuples(NdbScanOperation::LM_Read, 0, parallelism);
  970.     } else {
  971.       rs = pOp->readTuples(NdbScanOperation::LM_CommittedRead, 0, parallelism);
  972.     }
  973.     
  974.     if( rs == 0 ) {
  975.       ERR(pTrans->getNdbError());
  976.       pNdb->closeTransaction(pTrans);
  977.       return NDBT_FAILED;
  978.     }
  980.     check = pOp->interpret_exit_ok();
  981.     if( check == -1 ) {
  982.       ERR(pTrans->getNdbError());
  983.       pNdb->closeTransaction(pTrans);
  984.       return NDBT_FAILED;
  985.     }
  987.     // Read all attributes
  988.     for (int a = 0; a < tab.getNoOfColumns(); a++){
  989.       if ((row.attributeStore(a) =  
  990.    pOp->getValue(tab.getColumn(a)->getName())) == 0) {
  991. ERR(pTrans->getNdbError());
  992. pNdb->closeTransaction(pTrans);
  993. return NDBT_FAILED;
  994.       }
  995.     }
  997.     check = pTrans->execute(NoCommit);
  998.     if( check == -1 ) {
  999.       const NdbError err = pTrans->getNdbError();
  1000.       
  1001.       if (err.status == NdbError::TemporaryError){
  1002. ERR(err);
  1003. pNdb->closeTransaction(pTrans);
  1004. NdbSleep_MilliSleep(50);
  1005. retryAttempt++;
  1006. continue;
  1007.       }
  1008.       ERR(err);
  1009.       pNdb->closeTransaction(pTrans);
  1010.       return NDBT_FAILED;
  1011.     }
  1012.     
  1013.     int eof;
  1014.     int rows = 0;
  1015.     
  1016.     
  1017.     while((eof = rs->nextResult()) == 0){
  1018.       rows++;
  1019.       
  1020.       // ndbout << row.c_str().c_str() << endl;
  1021.       
  1022.       
  1023.       if (readRowFromTableAndIndex(pNdb,
  1024.    pTrans,
  1025.    pIndex,
  1026.    row) != NDBT_OK){
  1027. pNdb->closeTransaction(pTrans);
  1028. return NDBT_FAILED;
  1029.       }
  1030.     }
  1031.     if (eof == -1) {
  1032.       const NdbError err = pTrans->getNdbError();
  1033.       
  1034.       if (err.status == NdbError::TemporaryError){
  1035. ERR(err);
  1036. pNdb->closeTransaction(pTrans);
  1037. NdbSleep_MilliSleep(50);
  1038. retryAttempt++;
  1039. rows--;
  1040. continue;
  1041.       }
  1042.       ERR(err);
  1043.       pNdb->closeTransaction(pTrans);
  1044.       return NDBT_FAILED;
  1045.     }
  1046.     
  1047.     pNdb->closeTransaction(pTrans);
  1048.     
  1049.     return NDBT_OK;
  1050.   }
  1051.   return NDBT_FAILED;
  1052. }
  1053. int 
  1054. UtilTransactions::readRowFromTableAndIndex(Ndb* pNdb,
  1055.    NdbConnection* scanTrans,
  1056.    const NdbDictionary::Index* pIndex,
  1057.    NDBT_ResultRow& row ){
  1060.   NdbDictionary::Index::Type indexType= pIndex->getType();
  1061.   int                  retryAttempt = 0;
  1062.   const int            retryMax = 100;
  1063.   int                  check, a;
  1064.   NdbConnection        *pTrans1=NULL;
  1065.   NdbResultSet         *cursor= NULL;
  1066.   NdbOperation        *pOp;
  1068.   int return_code= NDBT_FAILED;
  1070.   // Allocate place to store the result
  1071.   NDBT_ResultRow       tabRow(tab);
  1072.   NDBT_ResultRow       indexRow(tab);
  1073.   const char * indexName = pIndex->getName();
  1075.   while (true){
  1076.     if(retryAttempt)
  1077.       ndbout_c("retryAttempt %d", retryAttempt);
  1078.     if (retryAttempt >= retryMax){
  1079.       g_info << "ERROR: has retried this operation " << retryAttempt 
  1080.      << " times, failing!" << endl;
  1081. goto close_all;
  1082.     }
  1084.     pTrans1 = pNdb->hupp(scanTrans); //startTransaction();
  1085.     if (pTrans1 == NULL) {
  1086.       const NdbError err = pNdb->getNdbError();
  1087.       
  1088.       if (err.status == NdbError::TemporaryError){
  1089. ERR(err);
  1090. NdbSleep_MilliSleep(50);
  1091. retryAttempt++;
  1092. continue;
  1093.       }
  1095.       if(err.code == 0){
  1096. return_code = NDBT_OK;
  1097. goto close_all;
  1098.       }
  1099.       ERR(err);
  1100.       goto close_all;
  1101.     }
  1103.     /**
  1104.      * Read the record from TABLE
  1105.      */
  1106.     pOp = pTrans1->getNdbOperation(tab.getName());
  1107.     if (pOp == NULL) {
  1108.       ERR(pTrans1->getNdbError());
  1109.       goto close_all;
  1110.     }
  1111.     
  1112.     check = pOp->readTuple();
  1113.     if( check == -1 ) {
  1114.       ERR(pTrans1->getNdbError());
  1115.       pNdb->closeTransaction(pTrans1);
  1116.       goto close_all;
  1117.     }
  1118.     
  1119.     // Define primary keys
  1120. #if VERBOSE
  1121.     printf("PK: ");
  1122. #endif
  1123.     for(a = 0; a<tab.getNoOfColumns(); a++){
  1124.       const NdbDictionary::Column* attr = tab.getColumn(a);
  1125.       if (attr->getPrimaryKey() == true){
  1126. if (pOp->equal(attr->getName(), row.attributeStore(a)->aRef()) != 0){
  1127.   ERR(pTrans1->getNdbError());
  1128.   goto close_all;
  1129. }
  1130. #if VERBOSE
  1131. printf("%s = %d: ", attr->getName(), row.attributeStore(a)->aRef());
  1132. #endif
  1133.       }
  1134.     }
  1135. #if VERBOSE
  1136.     printf("n");
  1137. #endif
  1138.     // Read all attributes
  1139. #if VERBOSE
  1140.     printf("Reading %u attributes: ", tab.getNoOfColumns());
  1141. #endif
  1142.     for(a = 0; a<tab.getNoOfColumns(); a++){
  1143.       if((tabRow.attributeStore(a) = 
  1144.   pOp->getValue(tab.getColumn(a)->getName())) == 0) {
  1145. ERR(pTrans1->getNdbError());
  1146. goto close_all;
  1147.       }
  1148. #if VERBOSE
  1149.       printf("%s ", tab.getColumn(a)->getName());
  1150. #endif
  1151.     }
  1152. #if VERBOSE
  1153.     printf("n");
  1154. #endif
  1156.     /**
  1157.      * Read the record from INDEX_TABLE
  1158.      */    
  1159.     NdbIndexOperation* pIndexOp= NULL;
  1160.     NdbIndexScanOperation *pScanOp= NULL;
  1161.     NdbOperation *pIOp= 0;
  1163.     bool null_found= false;
  1164.     for(a = 0; a<(int)pIndex->getNoOfColumns(); a++){
  1165.       const NdbDictionary::Column *  col = pIndex->getColumn(a);
  1166.       
  1167.       if (row.attributeStore(col->getName())->isNULL())
  1168.       {
  1169. null_found= true;
  1170. break;
  1171.       }
  1172.     }
  1173.     
  1174.     const char * tabName= tab.getName();
  1175.     if(!null_found)
  1176.     {
  1177.       if (indexType == NdbDictionary::Index::UniqueHashIndex) {
  1178. pIOp= pIndexOp= pTrans1->getNdbIndexOperation(indexName, tabName);
  1179.       } else {
  1180. pIOp= pScanOp= pTrans1->getNdbIndexScanOperation(indexName, tabName);
  1181.       }
  1182.       
  1183.       if (pIOp == NULL) {
  1184. ERR(pTrans1->getNdbError());
  1185. goto close_all;
  1186.       }
  1187.     
  1188.       {
  1189. bool not_ok;
  1190. if (pIndexOp) {
  1191.   not_ok = pIndexOp->readTuple() == -1;
  1192. } else {
  1193.   not_ok = (cursor= pScanOp->readTuples()) == 0;
  1194. }
  1196. if( not_ok ) {
  1197.   ERR(pTrans1->getNdbError());
  1198.   goto close_all;
  1199. }
  1200.       }
  1201.     
  1202.     // Define primary keys for index
  1203. #if VERBOSE
  1204.       printf("SI: ");
  1205. #endif
  1206.       for(a = 0; a<(int)pIndex->getNoOfColumns(); a++){
  1207. const NdbDictionary::Column *  col = pIndex->getColumn(a);
  1209. int r;
  1210. if ( !row.attributeStore(col->getName())->isNULL() ) {
  1211.   if(pIOp->equal(col->getName(), 
  1212.  row.attributeStore(col->getName())->aRef()) != 0){
  1213.     ERR(pTrans1->getNdbError());
  1214.     goto close_all;
  1215.   }
  1216. }
  1217. #if VERBOSE
  1218. printf("%s = %d: ", col->getName(), row.attributeStore(a)->aRef());
  1219. #endif
  1220.       }
  1221. #if VERBOSE
  1222.       printf("n");
  1223. #endif
  1224.       
  1225.       // Read all attributes
  1226. #if VERBOSE
  1227.       printf("Reading %u attributes: ", tab.getNoOfColumns());
  1228. #endif
  1229.       for(a = 0; a<tab.getNoOfColumns(); a++){
  1230. void* pCheck;
  1232. pCheck= indexRow.attributeStore(a)= 
  1233.   pIOp->getValue(tab.getColumn(a)->getName());
  1235. if(pCheck == NULL) {
  1236.   ERR(pTrans1->getNdbError());
  1237.   goto close_all;
  1238. }
  1239. #if VERBOSE
  1240. printf("%s ", tab.getColumn(a)->getName());
  1241. #endif
  1242.       }
  1243.     }
  1244. #if VERBOSE
  1245.     printf("n");
  1246. #endif
  1247.     
  1248.     check = pTrans1->execute(Commit);
  1249.     if( check == -1 ) {
  1250.       const NdbError err = pTrans1->getNdbError();
  1251.       
  1252.       if (err.status == NdbError::TemporaryError){
  1253. ERR(err);
  1254. pNdb->closeTransaction(pTrans1);
  1255. NdbSleep_MilliSleep(50);
  1256. retryAttempt++;
  1257. continue;
  1258.       }
  1259.       ndbout << "Error when comparing records - normal op" << endl;
  1260.       ERR(err);
  1261.       ndbout << "row: " << row.c_str().c_str() << endl;
  1262.       goto close_all;
  1263.     } 
  1264.     
  1265.     /** 
  1266.      * Compare the two rows
  1267.      */ 
  1268.     if(!null_found){
  1269.       if (pScanOp) {
  1270. if (cursor->nextResult() != 0){
  1271.   const NdbError err = pTrans1->getNdbError();
  1272.   ERR(err);
  1273.   ndbout << "Error when comparing records - index op next_result missing" << endl;
  1274.   ndbout << "row: " << row.c_str().c_str() << endl;
  1275.   goto close_all;
  1276. }
  1277.       }
  1278.       if (!(tabRow.c_str() == indexRow.c_str())){
  1279. ndbout << "Error when comapring records" << endl;
  1280. ndbout << " tabRow: n" << tabRow.c_str().c_str() << endl;
  1281. ndbout << " indexRow: n" << indexRow.c_str().c_str() << endl;
  1282. goto close_all;
  1283.       }
  1284.       if (pScanOp) {
  1285. if (cursor->nextResult() == 0){
  1286.   ndbout << "Error when comparing records - index op next_result to many" << endl;
  1287.   ndbout << "row: " << row.c_str().c_str() << endl;
  1288.   goto close_all;
  1289. }
  1290.       }
  1291.     }
  1292.     return_code= NDBT_OK;
  1293.     goto close_all;
  1294.   }
  1295.   
  1296. close_all:
  1297.   if (cursor)
  1298.     cursor->close();
  1299.   if (pTrans1)
  1300.     pNdb->closeTransaction(pTrans1);
  1301.   
  1302.   return return_code;
  1303. }
  1305. int 
  1306. UtilTransactions::verifyOrderedIndex(Ndb* pNdb,
  1307.      const NdbDictionary::Index* pIndex,
  1308.      int parallelism,
  1309.      bool transactional){
  1310.   
  1311.   int                  retryAttempt = 0;
  1312.   const int            retryMax = 100;
  1313.   int                  check;
  1314.   NdbConnection        *pTrans;
  1315.   NdbScanOperation     *pOp;
  1316.   NdbIndexScanOperation * iop = 0;
  1317.   NdbResultSet* cursor= 0;
  1319.   NDBT_ResultRow       scanRow(tab);
  1320.   NDBT_ResultRow       pkRow(tab);
  1321.   NDBT_ResultRow       indexRow(tab);
  1322.   const char * indexName = pIndex->getName();
  1324.   int res;
  1325.   parallelism = 1;
  1326.   
  1327.   while (true){
  1329.     if (retryAttempt >= retryMax){
  1330.       g_info << "ERROR: has retried this operation " << retryAttempt 
  1331.      << " times, failing!" << endl;
  1332.       return NDBT_FAILED;
  1333.     }
  1335.     pTrans = pNdb->startTransaction();
  1336.     if (pTrans == NULL) {
  1337.       const NdbError err = pNdb->getNdbError();
  1339.       if (err.status == NdbError::TemporaryError){
  1340. ERR(err);
  1341. NdbSleep_MilliSleep(50);
  1342. retryAttempt++;
  1343. continue;
  1344.       }
  1345.       ERR(err);
  1346.       return NDBT_FAILED;
  1347.     }
  1349.     pOp = pTrans->getNdbScanOperation(tab.getName());
  1350.     if (pOp == NULL) {
  1351.       ERR(pTrans->getNdbError());
  1352.       pNdb->closeTransaction(pTrans);
  1353.       return NDBT_FAILED;
  1354.     }
  1356.     NdbResultSet* 
  1357.       rs = pOp->readTuples(NdbScanOperation::LM_Read, 0, parallelism);
  1358.     
  1359.     if( rs == 0 ) {
  1360.       ERR(pTrans->getNdbError());
  1361.       pNdb->closeTransaction(pTrans);
  1362.       return NDBT_FAILED;
  1363.     }
  1365.     check = pOp->interpret_exit_ok();
  1366.     if( check == -1 ) {
  1367.       ERR(pTrans->getNdbError());
  1368.       pNdb->closeTransaction(pTrans);
  1369.       return NDBT_FAILED;
  1370.     }
  1372.     if(get_values(pOp, scanRow))
  1373.     {
  1374.       abort();
  1375.     }
  1377.     check = pTrans->execute(NoCommit);
  1378.     if( check == -1 ) {
  1379.       const NdbError err = pTrans->getNdbError();
  1380.       
  1381.       if (err.status == NdbError::TemporaryError){
  1382. ERR(err);
  1383. pNdb->closeTransaction(pTrans);
  1384. NdbSleep_MilliSleep(50);
  1385. retryAttempt++;
  1386. continue;
  1387.       }
  1388.       ERR(err);
  1389.       pNdb->closeTransaction(pTrans);
  1390.       return NDBT_FAILED;
  1391.     }
  1392.         
  1393.     int eof;
  1394.     int rows = 0;
  1395.     while(check == 0 && (eof = rs->nextResult()) == 0){
  1396.       rows++;
  1398.       bool null_found= false;
  1399.       for(int a = 0; a<(int)pIndex->getNoOfColumns(); a++){
  1400. const NdbDictionary::Column *  col = pIndex->getColumn(a);
  1401. if (scanRow.attributeStore(col->getName())->isNULL())
  1402. {
  1403.   null_found= true;
  1404.   break;
  1405. }
  1406.       }
  1407.       
  1408.       // Do pk lookup
  1409.       NdbOperation * pk = pTrans->getNdbOperation(tab.getName());
  1410.       if(!pk || pk->readTuple())
  1411. goto error;
  1412.       if(equal(&tab, pk, scanRow) || get_values(pk, pkRow))
  1413. goto error;
  1415.       if(!null_found)
  1416.       {
  1417. if(!iop && (iop= pTrans->getNdbIndexScanOperation(indexName, 
  1418.   tab.getName())))
  1419. {
  1420.   cursor= iop->readTuples(NdbScanOperation::LM_CommittedRead, 
  1421.   parallelism);
  1422.   iop->interpret_exit_ok();
  1423.   if(!cursor || get_values(iop, indexRow))
  1424.     goto error;
  1425. }
  1426. else if(!iop || iop->reset_bounds())
  1427. {
  1428.   goto error;
  1429. }
  1431. if(equal(pIndex, iop, scanRow))
  1432.   goto error;
  1433.       }     
  1435.       check = pTrans->execute(NoCommit);
  1436.       if(check)
  1437. goto error;
  1439.       if(scanRow.c_str() != pkRow.c_str()){
  1440. g_err << "Error when comapring records" << endl;
  1441. g_err << " scanRow: n" << scanRow.c_str().c_str() << endl;
  1442. g_err << " pkRow: n" << pkRow.c_str().c_str() << endl;
  1443. pNdb->closeTransaction(pTrans);
  1444. return NDBT_FAILED;
  1445.       }
  1447.       if(!null_found)
  1448.       {
  1450. if((res= cursor->nextResult()) != 0){
  1451.   g_err << "Failed to find row using index: " << res << endl;
  1452.   ERR(pTrans->getNdbError());
  1453.   pNdb->closeTransaction(pTrans);
  1454.   return NDBT_FAILED;
  1455. }
  1457. if(scanRow.c_str() != indexRow.c_str()){
  1458.   g_err << "Error when comapring records" << endl;
  1459.   g_err << " scanRow: n" << scanRow.c_str().c_str() << endl;
  1460.   g_err << " indexRow: n" << indexRow.c_str().c_str() << endl;
  1461.   pNdb->closeTransaction(pTrans);
  1462.   return NDBT_FAILED;
  1463. }
  1465. if(cursor->nextResult() == 0){
  1466.   g_err << "Found extra row!!" << endl;
  1467.   g_err << " indexRow: n" << indexRow.c_str().c_str() << endl;
  1468.   pNdb->closeTransaction(pTrans);
  1469.   return NDBT_FAILED;
  1470. }
  1471.       }
  1472.     }
  1473.     
  1474.     if (eof == -1 || check == -1) {
  1475.   error:
  1476.       const NdbError err = pTrans->getNdbError();
  1477.       
  1478.       if (err.status == NdbError::TemporaryError){
  1479. ERR(err);
  1480. iop = 0;
  1481. pNdb->closeTransaction(pTrans);
  1482. NdbSleep_MilliSleep(50);
  1483. retryAttempt++;
  1484. rows--;
  1485. continue;
  1486.       }
  1487.       ERR(err);
  1488.       pNdb->closeTransaction(pTrans);
  1489.       return NDBT_FAILED;
  1490.     }
  1491.       
  1492.     pNdb->closeTransaction(pTrans);
  1493.     
  1494.     return NDBT_OK;
  1495.   }
  1496.   return NDBT_FAILED;
  1497. }
  1499. int
  1500. UtilTransactions::get_values(NdbOperation* op, NDBT_ResultRow& dst)
  1501. {
  1502.   for (int a = 0; a < tab.getNoOfColumns(); a++){
  1503.     NdbRecAttr*& ref= dst.attributeStore(a);
  1504.     if ((ref= op->getValue(a)) == 0)
  1505.     {
  1506.       return NDBT_FAILED;
  1507.     }
  1508.   }
  1509.   return 0;
  1510. }
  1512. int
  1513. UtilTransactions::equal(const NdbDictionary::Index* pIndex, 
  1514. NdbOperation* op, const NDBT_ResultRow& src)
  1515. {
  1516.   for(Uint32 a = 0; a<pIndex->getNoOfColumns(); a++){
  1517.     const NdbDictionary::Column *  col = pIndex->getColumn(a);
  1518.     if(op->equal(col->getName(), 
  1519.  src.attributeStore(col->getName())->aRef()) != 0){
  1520.       return NDBT_FAILED;
  1521.     }
  1522.   }
  1523.   return 0;
  1524. }
  1526. int
  1527. UtilTransactions::equal(const NdbDictionary::Table* pTable, 
  1528. NdbOperation* op, const NDBT_ResultRow& src)
  1529. {
  1530.   for(Uint32 a = 0; a<tab.getNoOfColumns(); a++){
  1531.     const NdbDictionary::Column* attr = tab.getColumn(a);
  1532.     if (attr->getPrimaryKey() == true){
  1533.       if (op->equal(attr->getName(), src.attributeStore(a)->aRef()) != 0){
  1534. return NDBT_FAILED;
  1535.       }
  1536.     }
  1537.   }
  1538.   return 0;
  1539. }