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

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

MySQL数据库

开发平台：

Visual C++

ScanInterpretTest.hpp：源码内容
  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. #ifndef SCAN_INTERPRET_TEST_HPP
  18. #define SCAN_INTERPRET_TEST_HPP
  20. #include "ScanFilter.hpp"
  22. class ScanInterpretTest {
  23. public:
  24.   ScanInterpretTest(const NdbDictionary::Table& _tab, 
  25.     const NdbDictionary::Table& _restab) : 
  26.     tab(_tab),
  27.     restab(_restab),
  28.     row(_tab){
  29.   }
  31.   int scanRead(Ndb*, 
  32.        int records,
  33.        int parallelism,
  34.        ScanFilter& filter);
  35.   int scanReadVerify(Ndb*, 
  36.      int records,
  37.      int parallelism,
  38.      ScanFilter& filter);
  40.   int addRowToInsert(Ndb* pNdb, 
  41.      NdbConnection* pInsTrans);
  42.   int addRowToCheckTrans(Ndb* pNdb, 
  43.  NdbConnection* pCheckTrans);
  44. private:
  45.   const NdbDictionary::Table& tab;
  46.   const NdbDictionary::Table& restab;
  47.   NDBT_ResultRow row;
  48.   
  49. };
  52. inline
  53. int 
  54. ScanInterpretTest::addRowToInsert(Ndb* pNdb, 
  55.   NdbConnection* pInsTrans){
  57.   NdbOperation* pOp = 
  58.     pInsTrans->getNdbOperation(restab.getName());
  59.   if (pOp == NULL) {
  60.     ERR(pInsTrans->getNdbError());
  61.     pNdb->closeTransaction(pInsTrans);
  62.     return NDBT_FAILED;
  63.   }
  64.   
  65.   if( pOp->insertTuple() == -1 ) {
  66.     ERR(pInsTrans->getNdbError());
  67.     pNdb->closeTransaction(pInsTrans);
  68.     return NDBT_FAILED;
  69.   }
  70.   
  71.   // Copy all attribute to the new operation
  72.   for (int a = 0; a<restab.getNoOfColumns(); a++){
  73.     const NdbDictionary::Column* attr = tab.getColumn(a); 
  74.     NdbRecAttr* reca = row.attributeStore(a);
  75.     int check = -1;
  76.     switch (attr->getType()){
  77.     case NdbDictionary::Column::Char:
  78.     case NdbDictionary::Column::Varchar:
  79.     case NdbDictionary::Column::Binary:
  80.     case NdbDictionary::Column::Varbinary:{
  81.       check = pOp->setValue( attr->getName(), 
  82.      reca->aRef());
  83.       break;
  84.     }
  85.     case NdbDictionary::Column::Int:{
  86.       check = pOp->setValue( attr->getName(), 
  87.      reca->int32_value());      
  88.     }
  89.       break;
  90.     case NdbDictionary::Column::Bigint:{
  91.       check = pOp->setValue( attr->getName(), 
  92.      reca->int64_value());
  93.     }
  94.       break;
  95.     case NdbDictionary::Column::Unsigned:{
  96.       check = pOp->setValue( attr->getName(), 
  97.      reca->u_32_value());
  98.     }
  99.       break;
  100.     case NdbDictionary::Column::Bigunsigned:{
  101.       check = pOp->setValue( attr->getName(), 
  102.      reca->u_64_value());
  103.     }
  104.       break;
  105.     case NdbDictionary::Column::Float:
  106.       check = pOp->setValue( attr->getName(), 
  107.      reca->float_value());
  109.       break;
  110.     default:
  111.       check = -1;
  112.       break;
  113.     }
  114.     if(check != 0){
  115.       ERR(pInsTrans->getNdbError());
  116.       pNdb->closeTransaction(pInsTrans);
  117.       return NDBT_FAILED;
  118.     }
  119.   }
  120.   
  121.   return NDBT_OK;
  122. }
  124. inline
  125. int 
  126. ScanInterpretTest::addRowToCheckTrans(Ndb* pNdb, 
  127.       NdbConnection* pCheckTrans){
  129.   NdbOperation* pOp = 
  130.     pCheckTrans->getNdbOperation(restab.getName());
  131.   if (pOp == NULL) {
  132.     ERR(pNdb->getNdbError());
  133.     return NDBT_FAILED;
  134.   }
  135.   
  136.   if(pOp->readTuple() != 0) {
  137.     ERR(pNdb->getNdbError());
  138.     return NDBT_FAILED;
  139.   }
  140.   
  141.   // Copy pk attribute's to the new operation
  142.   for (int a = 0; a<restab.getNoOfColumns(); a++){
  143.     const NdbDictionary::Column* attr = restab.getColumn(a); 
  144.     if (attr->getPrimaryKey() == true){
  145.       NdbRecAttr* reca = row.attributeStore(a);
  146.       int check = -1;
  147.       switch (attr->getType()){
  148.       case NdbDictionary::Column::Char:
  149.       case NdbDictionary::Column::Varchar:
  150.       case NdbDictionary::Column::Binary:
  151.       case NdbDictionary::Column::Varbinary:{
  152. check = pOp->equal( attr->getName(), 
  153.        reca->aRef());
  154. break;
  155.       }
  156.       case NdbDictionary::Column::Int:{
  157. check = pOp->equal( attr->getName(), 
  158.        reca->int32_value());      
  159.       }
  160. break;
  161.       case NdbDictionary::Column::Bigint:{
  162. check = pOp->equal( attr->getName(), 
  163.        reca->int64_value());
  164.       }
  165. break;
  166.       case NdbDictionary::Column::Unsigned:{
  167. check = pOp->equal( attr->getName(), 
  168.        reca->u_32_value());
  169.       }
  170. break;
  171.       case NdbDictionary::Column::Bigunsigned:{
  172. check = pOp->equal( attr->getName(), 
  173.        reca->u_64_value());
  174.       }
  175. break;
  176.       default:
  177. check = -1;
  178. break;
  179.       }
  180.       if(check != 0){
  181. ERR(pNdb->getNdbError());
  182. return NDBT_FAILED;
  183.       }
  184.     }
  185.   }
  187.   return NDBT_OK;
  188. }
  190. inline
  191. int 
  192. ScanInterpretTest::scanRead(Ndb* pNdb,
  193.     int records,
  194.     int parallelism,
  195.     ScanFilter& filter){
  196.   int                  retryAttempt = 0;
  197.   int            retryMax = 100;
  198.   int                  check;
  199.   NdbConnection        *pTrans;
  200.   NdbScanOperation        *pOp;
  202.   while (true){
  204.     if (retryAttempt >= retryMax){
  205.       ndbout << "ERROR: has retried this operation " << retryAttempt 
  206.      << " times, failing!" << endl;
  207.       return NDBT_FAILED;
  208.     }
  210.     pTrans = pNdb->startTransaction();
  211.     if (pTrans == NULL) {
  212.       const NdbError err = pNdb->getNdbError();
  213.       if (err.status == NdbError::TemporaryError){
  214. ERR(err);
  215. NdbSleep_MilliSleep(50);
  216. retryAttempt++;
  217. continue;
  218.       }
  219.       ERR(err);
  220.       return NDBT_FAILED;
  221.     }
  222.     
  223.     pOp = pTrans->getNdbScanOperation(tab.getName());
  224.     if (pOp == NULL) {
  225.       ERR(pTrans->getNdbError());
  226.       pNdb->closeTransaction(pTrans);
  227.       return NDBT_FAILED;
  228.     }
  229.    
  230.     NdbResultSet * rs = pOp->readTuples(NdbScanOperation::LM_Read, 
  231.                                         0, parallelism);
  232.  
  233.     if( rs == 0 ) {
  234.       ERR(pTrans->getNdbError());
  235.       pNdb->closeTransaction(pTrans);
  236.       return NDBT_FAILED;
  237.     }
  239.     if (filter.filterOp(pOp) != 0){
  240.       ERR(pTrans->getNdbError());
  241.       pNdb->closeTransaction(pTrans);
  242.       return NDBT_FAILED;
  243.     }
  244.     
  245.     // Read all attributes  
  246.     for(int a = 0; a<tab.getNoOfColumns(); a++){
  247.       if((row.attributeStore(a) = 
  248.   pOp->getValue(tab.getColumn(a)->getName())) == 0) {
  249. ERR(pTrans->getNdbError());
  250. pNdb->closeTransaction(pTrans);
  251. return NDBT_FAILED;
  252.       }
  253.     }      
  254.     check = pTrans->execute(NoCommit);   
  255.     if( check == -1 ) {
  256.       ERR(pTrans->getNdbError());
  257.       pNdb->closeTransaction(pTrans);
  258.       return NDBT_FAILED;
  259.     }
  261.     int eof;
  262.     int rows = 0;
  263.     NdbConnection* pInsTrans;
  265.     while((eof = rs->nextResult(true)) == 0){
  266.       do {
  267. rows++;
  268. if (addRowToInsert(pNdb, pTrans) != 0){
  269.   pNdb->closeTransaction(pTrans);
  270.   return NDBT_FAILED;
  271. }
  272.       } while((eof = rs->nextResult(false)) == 0);
  273.       
  274.       check = pTrans->execute(Commit);   
  275.       if( check == -1 ) {
  276. const NdbError err = pTrans->getNdbError();    
  277. ERR(err);
  278. pNdb->closeTransaction(pTrans);
  279. return NDBT_FAILED;
  280.       }
  281.     }
  282.     if (eof == -1) {
  283.       const NdbError err = pTrans->getNdbError();
  285.       if (err.status == NdbError::TemporaryError){
  286. ERR(err);
  287. pNdb->closeTransaction(pTrans);
  288. NdbSleep_MilliSleep(50);
  289. retryAttempt++;
  290. continue;
  291.       }
  292.       ERR(err);
  293.       pNdb->closeTransaction(pTrans);
  294.       return NDBT_FAILED;
  295.     }
  296.     
  297.     pNdb->closeTransaction(pTrans);
  299.     g_info << rows << " rows have been scanned" << endl;
  300.     
  301.     return NDBT_OK;
  302.   }
  303.   return NDBT_FAILED;
  304. }
  306. inline
  307. int 
  308. ScanInterpretTest::scanReadVerify(Ndb* pNdb,
  309.   int records,
  310.   int parallelism,
  311.   ScanFilter& filter){
  312.   int                  retryAttempt = 0;
  313.   const int            retryMax = 100;
  314.   int                  check;
  315.   NdbConnection        *pTrans;
  316.   NdbScanOperation        *pOp;
  317.   
  318.   while (true){
  319.     
  320.     if (retryAttempt >= retryMax){
  321.       ndbout << "ERROR: has retried this operation " << retryAttempt 
  322.      << " times, failing!" << endl;
  323.       return NDBT_FAILED;
  324.     }
  325.     
  326.     pTrans = pNdb->startTransaction();
  327.     if (pTrans == NULL) {
  328.       const NdbError err = pNdb->getNdbError();
  329.       if (err.status == NdbError::TemporaryError){
  330. ERR(err);
  331. NdbSleep_MilliSleep(50);
  332. retryAttempt++;
  333. continue;
  334.       }
  335.       ERR(err);
  336.       return NDBT_FAILED;
  337.     }
  338.     
  339.     
  340.     pOp = pTrans->getNdbScanOperation(tab.getName());
  341.     if (pOp == NULL) {  if (pOp->getValue("KOL2") == 0){
  342.     ERR(pNdb->getNdbError());
  343.     return NDBT_FAILED;
  344.   }
  345.   
  347.       ERR(pTrans->getNdbError());
  348.       pNdb->closeTransaction(pTrans);
  349.       return NDBT_FAILED;
  350.     }
  351.    
  352.     NdbResultSet * rs = pOp->readTuples(NdbScanOperation::LM_Read,
  353.                                         0, parallelism); 
  354.     if( rs == 0 ) {
  355.       ERR(pTrans->getNdbError());
  356.       pNdb->closeTransaction(pTrans);
  357.       return NDBT_FAILED;
  358.     }
  360.     check = pOp->interpret_exit_ok();
  361.     if (check == -1) {
  362.       ERR(pTrans->getNdbError());
  363.       pNdb->closeTransaction(pTrans);
  364.       return NDBT_FAILED;
  365.     }
  367.     
  368.     // Read all attributes  
  369.     for(int a = 0; a<tab.getNoOfColumns(); a++){
  370.       if((row.attributeStore(a) = 
  371.   pOp->getValue(tab.getColumn(a)->getName())) == 0) {
  372. ERR(pTrans->getNdbError());
  373. pNdb->closeTransaction(pTrans);
  374. return NDBT_FAILED;
  375.       }
  376.     }      
  377.     check = pTrans->execute(NoCommit);   
  378.     if( check == -1 ) {
  379.       ERR(pTrans->getNdbError());
  380.       pNdb->closeTransaction(pTrans);
  381.       return NDBT_FAILED;
  382.     }
  384.     int eof;
  385.     int rows = 0;
  386.     int rowsNoExist = 0;
  387.     int rowsExist = 0;    
  388.     int existingRecordsNotFound = 0;
  389.     int nonExistingRecordsFound = 0;
  392.     NdbConnection* pExistTrans;
  393.     NdbConnection* pNoExistTrans;
  394.     
  395.     while((eof = rs->nextResult(true)) == 0){
  396.       pExistTrans = pNdb->startTransaction();
  397.       if (pExistTrans == NULL) {
  398. const NdbError err = pNdb->getNdbError();
  399. ERR(err);
  400. return NDBT_FAILED;
  401.       }
  402.       pNoExistTrans = pNdb->startTransaction();
  403.       if (pNoExistTrans == NULL) {
  404. const NdbError err = pNdb->getNdbError();
  405. ERR(err);
  406. return NDBT_FAILED;
  407.       }
  408.       do {
  409. rows++;
  410. if (filter.verifyRecord(row) == NDBT_OK){
  411.   rowsExist++;
  412.   if (addRowToCheckTrans(pNdb, pExistTrans) != 0){
  413.     pNdb->closeTransaction(pTrans);
  414.     pNdb->closeTransaction(pExistTrans);
  415.     pNdb->closeTransaction(pNoExistTrans);
  416.     return NDBT_FAILED;
  417.   }
  418. }else{
  419.   rowsNoExist++;
  420.   if (addRowToCheckTrans(pNdb, pNoExistTrans) != 0){
  421.     pNdb->closeTransaction(pTrans);
  422.     pNdb->closeTransaction(pExistTrans);
  423.     pNdb->closeTransaction(pNoExistTrans);
  424.     return NDBT_FAILED;
  425.   }
  426. }
  427.       } while((eof = rs->nextResult(false)) == 0);
  430.       // Execute the transaction containing reads of 
  431.       // all the records that should be in the result table
  432.       check = pExistTrans->execute(Commit);   
  433.       if( check == -1 ) {
  434. const NdbError err = pExistTrans->getNdbError();    
  435. ERR(err);
  436. if (err.code != 626){
  437.   pNdb->closeTransaction(pExistTrans);
  438.   pNdb->closeTransaction(pNoExistTrans);
  439.   pNdb->closeTransaction(pTrans);
  440.   return NDBT_FAILED;
  441. }else{
  442.   // Some of the records expected to be found wasn't 
  443.   // there
  444.   existingRecordsNotFound = 1;
  445. }
  446.       }
  447.       pNdb->closeTransaction(pExistTrans);
  449.       // Execute the transaction containing reads of 
  450.       // all the records that should NOT be in the result table
  451.       check = pNoExistTrans->execute(Commit, CommitAsMuchAsPossible);   
  452.       if( check == -1 ) {
  453. const NdbError err = pNoExistTrans->getNdbError();    
  454. // The transactions error code should be zero
  455. if (err.code != 626){
  456.   ERR(err);
  457.   pNdb->closeTransaction(pNoExistTrans);
  458.   pNdb->closeTransaction(pTrans);
  459.   return NDBT_FAILED;
  460. }
  461. // Loop through the no existing transaction and check that no 
  462. // operations where successful
  463. const NdbOperation* pOp2 = NULL;
  464. while ((pOp2 = pNoExistTrans->getNextCompletedOperation(pOp2)) != NULL){
  465.   const NdbError err = pOp2->getNdbError();
  466.   if (err.code != 626){
  467.     ndbout << "err.code = " << err.code<< endl;
  468.     nonExistingRecordsFound = 1;
  469.   }
  470. }
  471.       } 
  472.       
  473.       pNdb->closeTransaction(pNoExistTrans);
  474.       
  476.     }
  477.     if (eof == -1) {
  478.       const NdbError err = pTrans->getNdbError();
  479.       
  480.       if (err.status == NdbError::TemporaryError){
  481. ERR(err);
  482. pNdb->closeTransaction(pTrans);
  483. NdbSleep_MilliSleep(50);
  484. retryAttempt++;
  485. continue;
  486.       }
  487.       ERR(err);
  488.       pNdb->closeTransaction(pTrans);
  489.       return NDBT_FAILED;
  490.     }
  491.     
  492.     int testResult = NDBT_OK;
  493.     int rowsResult = 0;
  494.     UtilTransactions utilTrans(restab);  
  495.     if (utilTrans.selectCount(pNdb, 
  496.       240,
  497.       &rowsResult) != 0){
  498.       return NDBT_FAILED;
  499.     }
  500.     if (existingRecordsNotFound == 1){
  501.       ndbout << "!!! Expected records not found" << endl;
  502.       testResult = NDBT_FAILED;
  503.     }
  504.     if (nonExistingRecordsFound == 1){
  505.       ndbout << "!!! Unxpected records found" << endl;
  506.       testResult = NDBT_FAILED;
  507.     }
  508.     ndbout << rows << " rows scanned("
  509.    << rowsExist << " found, " << rowsResult<<" expected)" << endl;
  510.     if (rowsResult != rowsExist){
  511.       ndbout << "!!! Number of rows in result table different from expected" << endl;
  512.       testResult = NDBT_FAILED;
  513.     }
  515.     return testResult;
  516.   }
  517.   return NDBT_FAILED;
  518. }
  520. #endif