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

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

MySQL数据库

开发平台：

Visual C++

HugoOperations.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 <HugoOperations.hpp>
  19. int HugoOperations::startTransaction(Ndb* pNdb){
  20.   
  21.   if (pTrans != NULL){
  22.     ndbout << "HugoOperations::startTransaction, pTrans != NULL" << endl;
  23.     return NDBT_FAILED;
  24.   }
  25.   pTrans = pNdb->startTransaction();
  26.   if (pTrans == NULL) {
  27.     const NdbError err = pNdb->getNdbError();
  28.     ERR(err);
  29.     return NDBT_FAILED;
  30.   }
  31.   return NDBT_OK;
  32. }
  34. void 
  35. HugoOperations::setTransactionId(Uint64 id){
  36.   if (pTrans != NULL){
  37.     pTrans->setTransactionId(id);
  38.   }
  39. }
  41. int HugoOperations::closeTransaction(Ndb* pNdb){
  43.   if (pTrans != NULL){
  44.     pNdb->closeTransaction(pTrans);
  45.     pTrans = NULL;
  46.   }
  47.   pTrans = NULL;
  49.   m_result_sets.clear();
  50.   m_executed_result_sets.clear();
  52.   return NDBT_OK;
  53. }
  55. NdbConnection* HugoOperations::getTransaction(){
  56.   return pTrans;
  57. }
  59. int HugoOperations::pkReadRecord(Ndb* pNdb,
  60.  int recordNo,
  61.  int numRecords,
  62.  NdbOperation::LockMode lm){
  63.   int a;  
  64.   allocRows(numRecords);
  65.   int check;
  66.   for(int r=0; r < numRecords; r++){
  67.     NdbOperation* pOp = pTrans->getNdbOperation(tab.getName());
  68.     if (pOp == NULL) {
  69.       ERR(pTrans->getNdbError());
  70.       return NDBT_FAILED;
  71.     }
  72.     
  73. rand_lock_mode:
  74.     switch(lm){
  75.     case NdbOperation::LM_Read:
  76.       check = pOp->readTuple();
  77.       break;
  78.     case NdbOperation::LM_Exclusive:
  79.       check = pOp->readTupleExclusive();
  80.       break;
  81.     case NdbOperation::LM_CommittedRead:
  82.       check = pOp->dirtyRead();
  83.       break;
  84.     default:
  85.       lm = (NdbOperation::LockMode)((rand() >> 16) & 3);
  86.       goto rand_lock_mode;
  87.     }
  88.     
  89.     if( check == -1 ) {
  90.       ERR(pTrans->getNdbError());
  91.       return NDBT_FAILED;
  92.     }
  93.     
  94.     // Define primary keys
  95.     for(a = 0; a<tab.getNoOfColumns(); a++){
  96.       if (tab.getColumn(a)->getPrimaryKey() == true){
  97. if(equalForAttr(pOp, a, r+recordNo) != 0){
  98.   ERR(pTrans->getNdbError());
  99.   return NDBT_FAILED;
  100. }
  101.       }
  102.     }
  103.     
  104.     // Define attributes to read  
  105.     for(a = 0; a<tab.getNoOfColumns(); a++){
  106.       if((rows[r]->attributeStore(a) = 
  107.   pOp->getValue(tab.getColumn(a)->getName())) == 0) {
  108. ERR(pTrans->getNdbError());
  109. return NDBT_FAILED;
  110.       }
  111.     } 
  112.   }
  113.   return NDBT_OK;
  114. }
  116. int HugoOperations::pkUpdateRecord(Ndb* pNdb,
  117.    int recordNo,
  118.    int numRecords,
  119.    int updatesValue){
  120.   int a; 
  121.   allocRows(numRecords);
  122.   int check;
  123.   for(int r=0; r < numRecords; r++){
  124.     NdbOperation* pOp = pTrans->getNdbOperation(tab.getName());
  125.     if (pOp == NULL) {
  126.       ERR(pTrans->getNdbError());
  127.       return NDBT_FAILED;
  128.     }
  129.     
  130.     check = pOp->updateTuple();
  131.     if( check == -1 ) {
  132.       ERR(pTrans->getNdbError());
  133.       return NDBT_FAILED;
  134.     }
  135.     
  136.     // Define primary keys
  137.     for(a = 0; a<tab.getNoOfColumns(); a++){
  138.       if (tab.getColumn(a)->getPrimaryKey() == true){
  139. if(equalForAttr(pOp, a, r+recordNo) != 0){
  140.   ERR(pTrans->getNdbError());
  141.   return NDBT_FAILED;
  142. }
  143.       }
  144.     }
  145.     
  146.     // Define attributes to update
  147.     for(a = 0; a<tab.getNoOfColumns(); a++){
  148.       if (tab.getColumn(a)->getPrimaryKey() == false){
  149. if(setValueForAttr(pOp, a, recordNo+r, updatesValue ) != 0){ 
  150.   ERR(pTrans->getNdbError());
  151.   return NDBT_FAILED;
  152. }
  153.       }
  154.     } 
  155.   }
  156.   return NDBT_OK;
  157. }
  159. int HugoOperations::pkInsertRecord(Ndb* pNdb,
  160.    int recordNo,
  161.    int numRecords,
  162.    int updatesValue){
  163.   
  164.   int a, check;
  165.   for(int r=0; r < numRecords; r++){
  166.     NdbOperation* pOp = pTrans->getNdbOperation(tab.getName());
  167.     if (pOp == NULL) {
  168.       ERR(pTrans->getNdbError());
  169.       return NDBT_FAILED;
  170.     }
  171.     
  172.     check = pOp->insertTuple();
  173.     if( check == -1 ) {
  174.       ERR(pTrans->getNdbError());
  175.       return NDBT_FAILED;
  176.     }
  177.     
  178.     // Define primary keys
  179.     for(a = 0; a<tab.getNoOfColumns(); a++){
  180.       if (tab.getColumn(a)->getPrimaryKey() == true){
  181. if(equalForAttr(pOp, a, r+recordNo) != 0){
  182.   ERR(pTrans->getNdbError());
  183.   return NDBT_FAILED;
  184. }
  185.       }
  186.     }
  187.     
  188.     // Define attributes to update
  189.     for(a = 0; a<tab.getNoOfColumns(); a++){
  190.       if (tab.getColumn(a)->getPrimaryKey() == false){
  191. if(setValueForAttr(pOp, a, recordNo+r, updatesValue ) != 0){ 
  192.   ERR(pTrans->getNdbError());
  193.   return NDBT_FAILED;
  194. }
  195.       }
  196.     } 
  197.   }
  198.   return NDBT_OK;
  199. }
  201. int HugoOperations::pkWriteRecord(Ndb* pNdb,
  202.   int recordNo,
  203.   int numRecords,
  204.   int updatesValue){
  205.   
  206.   int a, check;
  207.   for(int r=0; r < numRecords; r++){
  208.     NdbOperation* pOp = pTrans->getNdbOperation(tab.getName());
  209.     if (pOp == NULL) {
  210.       ERR(pTrans->getNdbError());
  211.       return NDBT_FAILED;
  212.     }
  213.     
  214.     check = pOp->writeTuple();
  215.     if( check == -1 ) {
  216.       ERR(pTrans->getNdbError());
  217.       return NDBT_FAILED;
  218.     }
  219.     
  220.     // Define primary keys
  221.     for(a = 0; a<tab.getNoOfColumns(); a++){
  222.       if (tab.getColumn(a)->getPrimaryKey() == true){
  223. if(equalForAttr(pOp, a, r+recordNo) != 0){
  224.   ERR(pTrans->getNdbError());
  225.   return NDBT_FAILED;
  226. }
  227.       }
  228.     }
  229.     
  230.     // Define attributes to update
  231.     for(a = 0; a<tab.getNoOfColumns(); a++){
  232.       if (tab.getColumn(a)->getPrimaryKey() == false){
  233. if(setValueForAttr(pOp, a, recordNo+r, updatesValue ) != 0){ 
  234.   ERR(pTrans->getNdbError());
  235.   return NDBT_FAILED;
  236. }
  237.       }
  238.     } 
  239.   }
  240.   return NDBT_OK;
  241. }
  243. int HugoOperations::pkDeleteRecord(Ndb* pNdb,
  244.    int recordNo,
  245.    int numRecords){
  246.   
  247.   int a, check;
  248.   for(int r=0; r < numRecords; r++){
  249.     NdbOperation* pOp = pTrans->getNdbOperation(tab.getName());
  250.     if (pOp == NULL) {
  251.       ERR(pTrans->getNdbError());
  252.       return NDBT_FAILED;
  253.     }
  254.     
  255.     check = pOp->deleteTuple();
  256.     if( check == -1 ) {
  257.       ERR(pTrans->getNdbError());
  258.       return NDBT_FAILED;
  259.     }
  260.     
  261.     // Define primary keys
  262.     for(a = 0; a<tab.getNoOfColumns(); a++){
  263.       if (tab.getColumn(a)->getPrimaryKey() == true){
  264. if(equalForAttr(pOp, a, r+recordNo) != 0){
  265.   ERR(pTrans->getNdbError());
  266.   return NDBT_FAILED;
  267. }
  268.       }
  269.     }
  270.   }
  271.   return NDBT_OK;
  272. }
  273. #if 0
  274. NdbResultSet*
  275. HugoOperations::scanReadRecords(Ndb* pNdb, ScanLock lock){
  276.   
  277.   NDBT_ResultRow * m_tmpRow = new NDBT_ResultRow(tab);
  279.   NdbScanOperation* pOp = pTrans->getNdbScanOperation(tab.getName());
  280.   if (pOp == NULL) {
  281.     ERR(pTrans->getNdbError());
  282.     return 0;
  283.   }
  284.   
  286.   int check = 0;
  287.   NdbResultSet * rs = 0;
  288.   switch(lock){
  289.   case SL_ReadHold:
  290.     rs = pOp->readTuples(NdbScanOperation::LM_Read, 1, 1);
  291.     break;
  292.   case SL_Exclusive:
  293.     rs = pOp->readTuples(NdbScanOperation::LM_Exclusive, 1, 1);
  294.     break;
  295.   case SL_Read:
  296.   default:
  297.     rs = pOp->readTuples(NdbScanOperation::LM_Dirty, 1, 1);
  298.   }
  299.   
  300.   if( rs == 0) {
  301.     ERR(pTrans->getNdbError());
  302.     return 0;
  303.   }
  304.   
  305.   check = pOp->interpret_exit_ok();
  306.   if( check == -1 ) {
  307.     ERR(pTrans->getNdbError());
  308.     return 0;
  309.   }
  310.   
  311.   // Define attributes to read  
  312.   for(int a = 0; a<tab.getNoOfColumns(); a++){
  313.     if((m_tmpRow->attributeStore(a) = 
  314. pOp->getValue(tab.getColumn(a)->getName())) == 0) {
  315.       ERR(pTrans->getNdbError());
  316.       return 0;
  317.     }
  318.   } 
  319.   return rs;
  320. }
  322. int
  323. HugoOperations::readTuples(NdbResultSet* rs){
  324.   int res = 0;
  325.   while((res = rs->nextResult()) == 0){
  326.   }
  327.   if(res != 1)
  328.     return NDBT_FAILED;
  329.   return NDBT_OK;
  330. }
  331. #endif
  333. int HugoOperations::execute_Commit(Ndb* pNdb,
  334.    AbortOption eao){
  336.   int check = 0;
  337.   check = pTrans->execute(Commit, eao);   
  339.   if( check == -1 ) {
  340.     const NdbError err = pTrans->getNdbError();
  341.     ERR(err);
  342.     NdbOperation* pOp = pTrans->getNdbErrorOperation();
  343.     if (pOp != NULL){
  344.       const NdbError err2 = pOp->getNdbError();
  345.       ERR(err2);
  346.     }
  347.     if (err.code == 0)
  348.       return NDBT_FAILED;
  349.     return err.code;
  350.   }
  352.   for(int i = 0; i<m_result_sets.size(); i++){
  353.     m_executed_result_sets.push_back(m_result_sets[i]);
  355.     int rows = m_result_sets[i].records;
  356.     NdbResultSet* rs = m_result_sets[i].m_result_set;
  357.     int res = rs->nextResult();
  358.     switch(res){
  359.     case 1:
  360.       return 626;
  361.     case -1:
  362.       const NdbError err = pTrans->getNdbError();
  363.       ERR(err);
  364.       return (err.code > 0 ? err.code : NDBT_FAILED);
  365.     }
  367.     // A row found
  369.     switch(rows){
  370.     case 0:
  371.       return 4000;
  372.     default:
  373.       m_result_sets[i].records--;
  374.       break;
  375.     }
  376.   }
  378.   m_result_sets.clear();
  379.   
  380.   return NDBT_OK;
  381. }
  383. int HugoOperations::execute_NoCommit(Ndb* pNdb, AbortOption eao){
  385.   int check;
  386.   check = pTrans->execute(NoCommit, eao);   
  388.   if( check == -1 ) {
  389.     const NdbError err = pTrans->getNdbError();
  390.     ERR(err);
  391.     NdbOperation* pOp;
  392.     while ((pOp = pTrans->getNdbErrorOperation()) != NULL){
  393.       const NdbError err2 = pOp->getNdbError();
  394.       ERR(err2);
  395.     }
  396.     if (err.code == 0)
  397.       return NDBT_FAILED;
  398.     return err.code;
  399.   }
  401.   for(int i = 0; i<m_result_sets.size(); i++){
  402.     m_executed_result_sets.push_back(m_result_sets[i]);
  404.     int rows = m_result_sets[i].records;
  405.     NdbResultSet* rs = m_result_sets[i].m_result_set;
  406.     int res = rs->nextResult();
  407.     switch(res){
  408.     case 1:
  409.       return 626;
  410.     case -1:
  411.       const NdbError err = pTrans->getNdbError();
  412.       ERR(err);
  413.       return (err.code > 0 ? err.code : NDBT_FAILED);
  414.     }
  416.     // A row found
  418.     switch(rows){
  419.     case 0:
  420.       return 4000;
  421.     default:
  422.     case 1:
  423.       break;
  424.     }
  425.   }
  427.   m_result_sets.clear();
  429.   return NDBT_OK;
  430. }
  432. int HugoOperations::execute_Rollback(Ndb* pNdb){
  433.   int check;
  434.   check = pTrans->execute(Rollback);   
  435.   if( check == -1 ) {
  436.     const NdbError err = pTrans->getNdbError();
  437.     ERR(err);
  438.     return NDBT_FAILED;
  439.   }
  440.   return NDBT_OK;
  441. }
  443. void
  444. HugoOperations_async_callback(int res, NdbConnection* pCon, void* ho)
  445. {
  446.   ((HugoOperations*)ho)->callback(res, pCon);
  447. }
  449. void
  450. HugoOperations::callback(int res, NdbConnection* pCon)
  451. {
  452.   assert(pCon == pTrans);
  453.   m_async_reply= 1;
  454.   m_async_return= res;
  455. }
  457. int 
  458. HugoOperations::execute_async(Ndb* pNdb, ExecType et, AbortOption eao){
  459.   
  460.   m_async_reply= 0;
  461.   pTrans->executeAsynchPrepare(et,
  462.        HugoOperations_async_callback,
  463.        this,
  464.        eao);
  465.   
  466.   pNdb->sendPreparedTransactions();
  467.   
  468.   return NDBT_OK;
  469. }
  471. int
  472. HugoOperations::wait_async(Ndb* pNdb, int timeout)
  473. {
  474.   pNdb->pollNdb(1000);
  476.   if(m_async_reply)
  477.   {
  478.     return m_async_return;
  479.   }
  480.   ndbout_c("wait returned nothing...");
  481.   return -1;
  482. }
  484. HugoOperations::HugoOperations(const NdbDictionary::Table& _tab):
  485.   UtilTransactions(_tab),
  486.   calc(_tab),
  487.   pTrans(NULL)
  488. {
  489. }
  491. HugoOperations::~HugoOperations(){
  492.   deallocRows();
  493.   if (pTrans != NULL)
  494.   {
  495.     pTrans->close();
  496.     pTrans = NULL;
  497.   }
  498. }
  501. int HugoOperations::equalForAttr(NdbOperation* pOp,
  502.    int attrId, 
  503.    int rowId){
  504.   int check = 0;
  505.   const NdbDictionary::Column* attr = tab.getColumn(attrId);  
  506.   if (attr->getPrimaryKey() == false){
  507.     g_info << "Can't call equalForAttr on non PK attribute" << endl;
  508.     return NDBT_FAILED;
  509.   }
  510.     
  511.   switch (attr->getType()){
  512.   case NdbDictionary::Column::Char:
  513.   case NdbDictionary::Column::Varchar:
  514.   case NdbDictionary::Column::Binary:
  515.   case NdbDictionary::Column::Varbinary:{
  516.     char buf[8000];
  517.     memset(buf, 0, sizeof(buf));
  518.     check = pOp->equal( attr->getName(), calc.calcValue(rowId, attrId, 0, buf));
  519.     break;
  520.   }
  521.   case NdbDictionary::Column::Int:
  522.     check = pOp->equal( attr->getName(), (Int32)calc.calcValue(rowId, attrId, 0));
  523.     break;
  524.   case NdbDictionary::Column::Unsigned:
  525.     check = pOp->equal( attr->getName(), (Uint32)calc.calcValue(rowId, attrId, 0));
  526.     break;
  527.   case NdbDictionary::Column::Bigint:
  528.     check = pOp->equal( attr->getName(), (Int64)calc.calcValue(rowId, attrId, 0));
  529.     break;
  530.   case NdbDictionary::Column::Bigunsigned:    
  531.     check = pOp->equal( attr->getName(), (Uint64)calc.calcValue(rowId, attrId, 0));
  532.     break;
  533.   case NdbDictionary::Column::Float:
  534.     g_info << "Float not allowed as PK value" << endl;
  535.     check = -1;
  536.     break;
  537.     
  538.   default:
  539.     g_info << "default" << endl;
  540.     check = -1;
  541.     break;
  542.   }
  543.   return check;
  544. }
  546. int HugoOperations::setValueForAttr(NdbOperation* pOp,
  547.       int attrId, 
  548.       int rowId,
  549.       int updateId){
  550.   int check = 0;
  551.   const NdbDictionary::Column* attr = tab.getColumn(attrId);     
  553.   if (attr->getTupleKey()){
  554.     // Don't set values for TupleId PKs
  555.     return check;
  556.   }
  557.   
  558.   switch (attr->getType()){
  559.   case NdbDictionary::Column::Char:
  560.   case NdbDictionary::Column::Varchar:
  561.   case NdbDictionary::Column::Binary:
  562.   case NdbDictionary::Column::Varbinary:{
  563.     char buf[8000];
  564.     check = pOp->setValue( attr->getName(), 
  565.    calc.calcValue(rowId, attrId, updateId, buf));
  566.     break;
  567.   }
  568.   case NdbDictionary::Column::Int:{
  569.     Int32 val = calc.calcValue(rowId, attrId, updateId);
  570.     check = pOp->setValue( attr->getName(), val);
  571.   }
  572.     break;
  573.   case NdbDictionary::Column::Bigint:{
  574.     Int64 val = calc.calcValue(rowId, attrId, updateId);
  575.     check = pOp->setValue( attr->getName(), 
  576.    val);
  577.   }
  578.     break;
  579.   case NdbDictionary::Column::Unsigned:{
  580.     Uint32 val = calc.calcValue(rowId, attrId, updateId);
  581.     check = pOp->setValue( attr->getName(), val);
  582.   }
  583.     break;
  584.   case NdbDictionary::Column::Bigunsigned:{
  585.     Uint64 val = calc.calcValue(rowId, attrId, updateId);
  586.     check = pOp->setValue( attr->getName(), 
  587.    val);
  588.   }
  589.     break;
  590.   case NdbDictionary::Column::Float:
  591.     check = pOp->setValue( attr->getName(), 
  592.    (float)calc.calcValue(rowId, attrId, updateId));
  593.     break;
  594.   default:
  595.     check = -1;
  596.     break;
  597.   }
  598.   return check;
  599. }
  601. int
  602. HugoOperations::verifyUpdatesValue(int updatesValue, int _numRows){
  603.   _numRows = (_numRows == 0 ? rows.size() : _numRows);
  604.   
  605.   int result = NDBT_OK;
  606.   
  607.   for(int i = 0; i<_numRows; i++){
  608.     if(calc.verifyRowValues(rows[i]) != NDBT_OK){
  609.       g_err << "Inconsistent row" 
  610.     << endl << "t" << rows[i]->c_str().c_str() << endl;
  611.       result = NDBT_FAILED;
  612.       continue;
  613.     }
  615.     if(calc.getUpdatesValue(rows[i]) != updatesValue){
  616.       result = NDBT_FAILED;
  617.       g_err << "Invalid updates value for row " << i << endl
  618.     << " updatesValue: " << updatesValue << endl
  619.     << " calc.getUpdatesValue: " << calc.getUpdatesValue(rows[i]) << endl 
  620.     << rows[i]->c_str().c_str() << endl;
  621.       continue;
  622.     }
  623.   }
  625.   if(_numRows == 0){
  626.     g_err << "No rows -> Invalid updates value" << endl;
  627.     return NDBT_FAILED;
  628.   }
  630.   return result;
  631. }
  633. void HugoOperations::allocRows(int _numRows){
  634.   deallocRows();
  636.   if(_numRows <= 0){
  637.     g_info << "Illegal value for num rows : " << _numRows << endl;
  638.     abort();
  639.   }
  640.   
  641.   for(int b=0; b<_numRows; b++){
  642.     rows.push_back(new NDBT_ResultRow(tab));
  643.   }
  644. }
  646. void HugoOperations::deallocRows(){
  647.   while(rows.size() > 0){
  648.     delete rows.back();
  649.     rows.erase(rows.size() - 1);
  650.   }
  651. }
  653. int HugoOperations::saveCopyOfRecord(int numRecords ){
  655.   if (numRecords > (int)rows.size())
  656.     return NDBT_FAILED;
  658.   for (int i = 0; i < numRecords; i++){
  659.     savedRecords.push_back(rows[i]->c_str());    
  660.   }
  661.   return NDBT_OK;  
  662. }
  664. BaseString HugoOperations::getRecordStr(int recordNum){
  665.   if (recordNum > (int)rows.size())
  666.     return NULL;
  667.   return rows[recordNum]->c_str();
  668. }
  670. int HugoOperations::getRecordGci(int recordNum){
  671.   return pTrans->getGCI();
  672. }
  675. int HugoOperations::compareRecordToCopy(int numRecords ){
  676.   if (numRecords > (int)rows.size())
  677.     return NDBT_FAILED;
  678.   if ((unsigned)numRecords > savedRecords.size())
  679.     return NDBT_FAILED;
  681.   int result = NDBT_OK;
  682.   for (int i = 0; i < numRecords; i++){
  683.     BaseString str = rows[i]->c_str();
  684.     ndbout << "row["<<i<<"]: " << str << endl;
  685.     ndbout << "sav["<<i<<"]: " << savedRecords[i] << endl;
  686.     if (savedRecords[i] == str){
  687.       ;
  688.     } else {
  689.       result = NDBT_FAILED;
  690.     }    
  691.   }
  692.   return result;
  693. }
  695. void
  696. HugoOperations::refresh() {
  697.   NdbConnection* t = getTransaction(); 
  698.   if(t)
  699.     t->refresh();
  700. }
  702. int HugoOperations::indexReadRecords(Ndb*, const char * idxName, int recordNo,
  703.      bool exclusive,
  704.      int numRecords){
  705.     
  706.   int a;
  707.   allocRows(numRecords);
  708.   int check;
  709.   for(int r=0; r < numRecords; r++){
  710.     NdbOperation* pOp = pTrans->getNdbIndexOperation(idxName, tab.getName());
  711.     if (pOp == NULL) {
  712.       ERR(pTrans->getNdbError());
  713.       return NDBT_FAILED;
  714.     }
  715.     
  716.     if (exclusive == true)
  717.       check = pOp->readTupleExclusive();
  718.     else
  719.       check = pOp->readTuple();
  720.     if( check == -1 ) {
  721.       ERR(pTrans->getNdbError());
  722.       return NDBT_FAILED;
  723.     }
  724.     
  725.     // Define primary keys
  726.     for(a = 0; a<tab.getNoOfColumns(); a++){
  727.       if (tab.getColumn(a)->getPrimaryKey() == true){
  728. if(equalForAttr(pOp, a, r+recordNo) != 0){
  729.   ERR(pTrans->getNdbError());
  730.   return NDBT_FAILED;
  731. }
  732.       }
  733.     }
  734.     
  735.     // Define attributes to read  
  736.     for(a = 0; a<tab.getNoOfColumns(); a++){
  737.       if((rows[r]->attributeStore(a) = 
  738.   pOp->getValue(tab.getColumn(a)->getName())) == 0) {
  739. ERR(pTrans->getNdbError());
  740. return NDBT_FAILED;
  741.       }
  742.     } 
  743.   }
  744.   return NDBT_OK;
  745. }
  747. int 
  748. HugoOperations::indexUpdateRecord(Ndb*,
  749.   const char * idxName, 
  750.   int recordNo,
  751.   int numRecords,
  752.   int updatesValue){
  753.   int a; 
  754.   allocRows(numRecords);
  755.   int check;
  756.   for(int r=0; r < numRecords; r++){
  757.     NdbOperation* pOp = pTrans->getNdbIndexOperation(idxName, tab.getName());
  758.     if (pOp == NULL) {
  759.       ERR(pTrans->getNdbError());
  760.       return NDBT_FAILED;
  761.     }
  762.     
  763.     check = pOp->updateTuple();
  764.     if( check == -1 ) {
  765.       ERR(pTrans->getNdbError());
  766.       return NDBT_FAILED;
  767.     }
  768.     
  769.     // Define primary keys
  770.     for(a = 0; a<tab.getNoOfColumns(); a++){
  771.       if (tab.getColumn(a)->getPrimaryKey() == true){
  772. if(equalForAttr(pOp, a, r+recordNo) != 0){
  773.   ERR(pTrans->getNdbError());
  774.   return NDBT_FAILED;
  775. }
  776.       }
  777.     }
  778.     
  779.     // Define attributes to update
  780.     for(a = 0; a<tab.getNoOfColumns(); a++){
  781.       if (tab.getColumn(a)->getPrimaryKey() == false){
  782. if(setValueForAttr(pOp, a, recordNo+r, updatesValue ) != 0){ 
  783.   ERR(pTrans->getNdbError());
  784.   return NDBT_FAILED;
  785. }
  786.       }
  787.     } 
  788.   }
  789.   return NDBT_OK;
  790. }
  792. int 
  793. HugoOperations::scanReadRecords(Ndb* pNdb, NdbScanOperation::LockMode lm,
  794. int records){
  796.   allocRows(records);
  797.   NdbScanOperation * pOp = pTrans->getNdbScanOperation(tab.getName());
  798.   
  799.   if(!pOp)
  800.     return -1;
  802.   NdbResultSet * rs = pOp->readTuples(lm, 1, 1);
  803.   
  804.   if(!rs){
  805.     return -1;
  806.   }
  808.   for(int a = 0; a<tab.getNoOfColumns(); a++){
  809.     if((rows[0]->attributeStore(a) = 
  810. pOp->getValue(tab.getColumn(a)->getName())) == 0) {
  811.       ERR(pTrans->getNdbError());
  812.       return NDBT_FAILED;
  813.     }
  814.   } 
  816.   RsPair p = {rs, records};
  817.   m_result_sets.push_back(p);
  818.   
  819.   return 0;
  820. }
  822. template class Vector<HugoOperations::RsPair>;