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

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

MySQL数据库

开发平台：

Visual C++

testNdbApi.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 <NDBT.hpp>
  18. #include <NDBT_Test.hpp>
  19. #include <HugoTransactions.hpp>
  20. #include <UtilTransactions.hpp>
  21. #include <NdbRestarter.hpp>
  22. #include <NdbRestarts.hpp>
  23. #include <Vector.hpp>
  24. #include <random.h>
  25. #include <NdbTick.h>
  27. #define MAX_NDB_OBJECTS 32678
  29. #define CHECK(b) if (!(b)) { 
  30.   ndbout << "ERR: "<< step->getName() 
  31.          << " failed on line " << __LINE__ << endl; 
  32.   result = NDBT_FAILED; 
  33.   continue; } 
  35. #define CHECKE(b) if (!(b)) { 
  36.   errors++; 
  37.   ndbout << "ERR: "<< step->getName() 
  38.          << " failed on line " << __LINE__ << endl; 
  39.   result = NDBT_FAILED; 
  40.   continue; } 
  43. int runTestMaxNdb(NDBT_Context* ctx, NDBT_Step* step){
  44.   Uint32 loops = ctx->getNumLoops();
  45.   Uint32 l = 0;
  46.   int oldi = 0;
  47.   int result = NDBT_OK;
  49.   while (l < loops && result == NDBT_OK){
  50.     ndbout_c("loop %d", l + 1);
  51.     int errors = 0;
  52.     int maxErrors = 5;
  53.     
  54.     Vector<Ndb*> ndbVector;
  55.     int i = 0;
  56.     int init = 0;
  57.     do {      
  58.       
  59.       Ndb* pNdb = new Ndb("TEST_DB");
  60.       if (pNdb == NULL){
  61. ndbout << "pNdb == NULL" << endl;      
  62. errors++;
  63. continue;
  65.       }
  66.       i++;
  68.       ndbVector.push_back(pNdb);
  69.       
  70.       if (pNdb->init()){
  71. ERR(pNdb->getNdbError());
  72. errors++;
  73. continue;
  74.       }
  75.       
  76.       init++;
  78.     } while (errors == 0);
  79.     
  80.     ndbout << i << " ndb objects created" << endl;
  81.     
  82.     if (l > 0 && i != oldi && init != MAX_NDB_OBJECTS){
  83.       ndbout << l << ": not as manyNdb objects created" << endl
  84.      << i << " != " << oldi << endl;
  85.       result =  NDBT_FAILED;
  86.     }
  88.     oldi = i;
  89.       
  90.     
  91.     for(size_t j = 0;  j < ndbVector.size(); j++){
  92.       delete ndbVector[j];
  93.       if(((j+1) % 250) == 0){
  94. ndbout << "Deleted " << (Uint64) j << " ndb objects " << endl;
  95.       }
  96.     }
  97.     ndbVector.clear();
  99.     l++;
  100.   }
  102.   return result;
  103. }
  105. int runTestMaxTransaction(NDBT_Context* ctx, NDBT_Step* step){
  106.   Uint32 loops = ctx->getNumLoops();
  107.   Uint32 l = 0;
  108.   int oldi = 0;
  109.   int result = NDBT_OK;
  111.   Ndb* pNdb = new Ndb("TEST_DB");
  112.   if (pNdb == NULL){
  113.     ndbout << "pNdb == NULL" << endl;      
  114.     return NDBT_FAILED;  
  115.   }
  116.   if (pNdb->init(2048)){
  117.     ERR(pNdb->getNdbError());
  118.     delete pNdb;
  119.     return NDBT_FAILED;
  120.   }
  122.   while (l < loops && result == NDBT_OK){
  123.     int errors = 0;
  124.     int maxErrors = 5;
  125.     
  126.     Vector<NdbConnection*> conVector;
  129.     int i = 0;
  130.     do {      
  132.       NdbConnection* pCon;
  133.       
  134.       int type = i%4;
  135.       switch (type){
  136.       case 0:
  137. pCon = pNdb->startTransaction();
  138. break;
  139.       case 1:
  140. pCon = pNdb->startTransaction(2,
  141.       "DATA",
  142.       4);
  143. break;
  144.       case 2:
  145. ndbout_c("startTransactionDGroup not supported");
  146. abort();
  147. /*   
  148. pCon = pNdb->startTransactionDGroup(1, 
  149.     "TEST",
  150.     0);
  151. */
  152. break;
  153.       case 3:      
  154. ndbout_c("startTransactionDGroup not supported");
  155. abort();
  156. /*   
  157. pCon = pNdb->startTransactionDGroup(2, 
  158.     "TEST",
  159.     1);
  160. */
  161. break;
  163.       default:
  164. abort();
  165.       }
  167.       if (pCon == NULL){
  168. ERR(pNdb->getNdbError());
  169. errors++;
  170. continue;
  171.       }
  172.   
  173.       conVector.push_back(pCon);
  174.         
  175.       i++;      
  176.     } while (errors < maxErrors);
  178.     ndbout << i << " connections created" << endl;
  180.     if (l > 0 && i != oldi){
  181.       ndbout << l << ": not as many transactions created" << endl
  182.      << i << " != " << oldi << endl;
  183.       result =  NDBT_FAILED;
  184.     }
  186.     oldi = i;
  187.       
  188.     
  189.     for(size_t j = 0; j < conVector.size(); j++){
  190.       pNdb->closeTransaction(conVector[j]);
  191.     }
  192.     conVector.clear();
  193.     l++;
  195.   }
  197.   // BONUS Test closeTransaction with null trans
  198.   pNdb->closeTransaction(NULL);
  200.   delete pNdb;
  203.   return result;
  204. }
  206. int runTestMaxOperations(NDBT_Context* ctx, NDBT_Step* step){
  207.   Uint32 l = 1;
  208.   int result = NDBT_OK;
  209.   int maxOpsLimit = 1;
  210.   const NdbDictionary::Table* pTab = ctx->getTab();
  212.   Ndb* pNdb = new Ndb("TEST_DB");
  213.   if (pNdb == NULL){
  214.     ndbout << "pNdb == NULL" << endl;      
  215.     return NDBT_FAILED;  
  216.   }
  217.   if (pNdb->init(2048)){
  218.     ERR(pNdb->getNdbError());
  219.     delete pNdb;
  220.     return NDBT_FAILED;
  221.   }
  223.   HugoOperations hugoOps(*pTab);
  225.   bool endTest = false;
  226.   while (!endTest && result == NDBT_OK){
  227.     int errors = 0;
  228.     int maxErrors = 5;
  230.     maxOpsLimit = l*1000;    
  231.        
  232.     if (hugoOps.startTransaction(pNdb) != NDBT_OK){
  233.       delete pNdb;
  234.       return NDBT_FAILED;
  235.     }
  236.     
  237.     int i = 0;
  238.     while (errors < maxErrors){
  239.       
  240.       if(hugoOps.pkReadRecord(pNdb,1, 1) != NDBT_OK){
  241. errors++;
  242. continue;
  243.       }
  244.         
  245.       i++;      
  247.       if (i >= maxOpsLimit){
  248. errors = maxErrors;
  249.       }
  251.     }
  253.     ndbout << i << " operations used" << endl;
  255.     int execResult = hugoOps.execute_Commit(pNdb);
  256.     switch(execResult){
  257.     case NDBT_OK:
  258.       break;
  259.     case 233: // Out of operation records in transaction coordinator      
  260.       // OK - end test
  261.       endTest = true;
  262.       break;
  263.     default:
  264.       result = NDBT_FAILED;
  265.       break;
  266.     }
  267.     
  268.     hugoOps.closeTransaction(pNdb);
  270.     l++;
  272.   }
  274.   delete pNdb;
  276.   return result;
  277. }
  279. int runTestGetValue(NDBT_Context* ctx, NDBT_Step* step){
  281.   int result = NDBT_OK;
  282.   const NdbDictionary::Table* pTab = ctx->getTab();
  284.   Ndb* pNdb = new Ndb("TEST_DB");
  285.   if (pNdb == NULL){
  286.     ndbout << "pNdb == NULL" << endl;      
  287.     return NDBT_FAILED;  
  288.   }
  289.   if (pNdb->init(2048)){
  290.     ERR(pNdb->getNdbError());
  291.     delete pNdb;
  292.     return NDBT_FAILED;
  293.   }
  295.   HugoOperations hugoOps(*pTab);
  296.   
  297.   for (int m = 1; m < 100; m++){
  298.     int errors = 0;
  299.     int maxErrors = 5;
  300.       
  301.     NdbConnection* pCon = pNdb->startTransaction();
  302.     if (pCon == NULL){
  303.       delete pNdb;
  304.       return NDBT_FAILED;
  305.     }
  306.       
  307.     NdbOperation* pOp = pCon->getNdbOperation(pTab->getName());
  308.     if (pOp == NULL){
  309.       pNdb->closeTransaction(pCon);
  310.       delete pNdb;
  311.       return NDBT_FAILED;
  312.     }
  313.       
  314.     if (pOp->readTuple() != 0){
  315.       pNdb->closeTransaction(pCon);
  316.       delete pNdb;
  317.       return NDBT_FAILED;
  318.     }
  319.       
  320.     for(int a = 0; a<pTab->getNoOfColumns(); a++){
  321.       if (pTab->getColumn(a)->getPrimaryKey() == true){
  322. if(hugoOps.equalForAttr(pOp, a, 1) != 0){
  323.   ERR(pCon->getNdbError());
  324.   pNdb->closeTransaction(pCon);
  325.   delete pNdb;
  326.   return NDBT_FAILED;
  327. }
  328.       }
  329.     }
  330.       
  331.     int i = 0;
  332.     int maxLimit = 1000*m;
  333.     do {      
  335.       if (pOp->getValue(pTab->getColumn(1)->getName()) == NULL) {
  336. const NdbError err = pCon->getNdbError();
  337. ERR(err);
  338. if (err.code == 0)
  339.   result = NDBT_FAILED;
  340. errors++;
  341. continue;
  342.       }
  344.       i++;             
  346.     } while (errors < maxErrors && i < maxLimit);
  347.       
  348.     ndbout << i << " getValues called" << endl;
  350.       
  351.     if (pCon->execute(Commit) != 0){
  352.       const NdbError err = pCon->getNdbError();
  353.       switch(err.code){
  354.       case 880: // TUP - Read too much
  355.       case 823: // TUP - Too much AI
  356.       case 4257: // NDBAPI - Too much AI
  357. // OK errors
  358. ERR(pCon->getNdbError());
  359. break;
  360.       default:
  361. ERR(pCon->getNdbError());
  362. ndbout << "Illegal error" << endl;
  363. result= NDBT_FAILED;
  364. break;
  365.       }
  366.     }
  367.       
  368.     pNdb->closeTransaction(pCon);
  370.   }// m
  373.   delete pNdb;
  375.   return result;
  376. }
  378. int runTestEqual(NDBT_Context* ctx, NDBT_Step* step){
  379.   Uint32 loops = ctx->getNumLoops();
  380.   Uint32 l = 0;
  381.   int result = NDBT_OK;
  382.   const NdbDictionary::Table* pTab = ctx->getTab();
  384.   Ndb* pNdb = new Ndb("TEST_DB");
  385.   if (pNdb == NULL){
  386.     ndbout << "pNdb == NULL" << endl;      
  387.     return NDBT_FAILED;  
  388.   }
  389.   if (pNdb->init(2048)){
  390.     ERR(pNdb->getNdbError());
  391.     delete pNdb;
  392.     return NDBT_FAILED;
  393.   }
  395.   HugoOperations hugoOps(*pTab);
  396.   
  397.   while (l < loops){
  398.     for(int m = 1; m < 10; m++){
  399.       int errors = 0;
  400.       int maxErrors = 5;
  401.       
  402.       NdbConnection* pCon = pNdb->startTransaction();
  403.       if (pCon == NULL){
  404. ndbout << "Could not start transaction" << endl;
  405. delete pNdb;
  406. return NDBT_FAILED;
  407.       }
  408.       
  409.       NdbOperation* pOp = pCon->getNdbOperation(pTab->getName());
  410.       if (pOp == NULL){
  411. ERR(pCon->getNdbError());
  412. pNdb->closeTransaction(pCon);
  413. delete pNdb;
  414. return NDBT_FAILED;
  415.       }
  416.       
  417.       if (pOp->readTuple() != 0){
  418. ERR(pCon->getNdbError());
  419. pNdb->closeTransaction(pCon);
  420. delete pNdb;
  421. return NDBT_FAILED;
  422.       }
  423.       
  424.       int i = 0;
  425.       int maxLimit = 1000*m;      
  426.       do {      
  428. if ((l%2)!=0){
  429.   // Forward
  430.   for(int a = 0; a<pTab->getNoOfColumns(); a++){
  431.     if (pTab->getColumn(a)->getPrimaryKey() == true){
  432.       if(hugoOps.equalForAttr(pOp, a, 1) != 0){
  433. const NdbError err = pCon->getNdbError();
  434. ERR(err);
  435. if (err.code == 0)
  436.   result = NDBT_FAILED;
  437. errors++;
  438.       }
  439.     }
  440.   }
  441. } else {
  442.   // Backward
  443.   for(int a = pTab->getNoOfColumns()-1; a>=0; a--){
  444.     if (pTab->getColumn(a)->getPrimaryKey() == true){
  445.       if(hugoOps.equalForAttr(pOp, a, 1) != 0){
  446. const NdbError err = pCon->getNdbError();
  447. ERR(err);
  448. if (err.code == 0)
  449.   result = NDBT_FAILED;
  450. errors++;
  451.       }
  452.     }
  453.   }
  454. }
  456. i++;      
  458.       } while (errors < maxErrors && i < maxLimit);
  459.       
  460.       if (pOp->getValue(pTab->getColumn(1)->getName()) == NULL) {
  461.         const NdbError err = pCon->getNdbError();
  462. ERR(pCon->getNdbError());
  463. pNdb->closeTransaction(pCon);
  464. delete pNdb;
  465.         if (err.code == 4225) {
  466.           return NDBT_OK;
  467.         } else {
  468.           return NDBT_FAILED;
  469.         }//if
  470.       }
  471.       
  472.       ndbout << i << " equal called" << endl;
  473.       
  474.       
  475.       int check = pCon->execute(Commit);
  476.       if (check != 0){
  477. ERR(pCon->getNdbError());
  478.       }
  479.       
  480.       pNdb->closeTransaction(pCon);
  481.       
  482.     }// m
  483.     l++;
  484.     
  485.   }// l
  486.   
  487.   delete pNdb;
  488.   return result;
  489. }
  491. int runTestDeleteNdb(NDBT_Context* ctx, NDBT_Step* step){
  492.   Uint32 loops = ctx->getNumLoops();
  493.   Uint32 l = 0;
  494.   int result = NDBT_OK;
  495.   NdbRestarts restarts;
  496.   Vector<Ndb*> ndbVector;
  497.   const NdbDictionary::Table* pTab = ctx->getTab();
  498.   HugoTransactions hugoTrans(*pTab);
  499.   int records = ctx->getNumRecords();
  500.   
  501.   while (l < loops && result == NDBT_OK){
  502.     
  503.     // Create 5 ndb objects
  504.     for( int i = 0; i < 5; i++){
  505.       Ndb* pNdb = new Ndb("TEST_DB");
  506.       if (pNdb == NULL){
  507. ndbout << "pNdb == NULL" << endl;      
  508. result = NDBT_FAILED;
  509. goto end_test;
  510.       }
  511.       ndbVector.push_back(pNdb);
  512.       
  513.       if (pNdb->init()){
  514. ERR(pNdb->getNdbError());
  515. result = NDBT_FAILED;
  516. goto end_test;
  517.       }
  518.       if (pNdb->waitUntilReady() != 0){
  519. ERR(pNdb->getNdbError());
  520. result = NDBT_FAILED;
  521. goto end_test;
  522.       }
  523.       if (hugoTrans.pkReadRecords(pNdb, records) != 0){
  524. result = NDBT_FAILED;
  525. goto end_test;
  526.       }
  527.     }
  528.     
  529.     if ((l % 2) == 0){
  530.       // Restart random node 
  531.       ndbout << "Restart random node " << endl;
  532.       if(restarts.executeRestart("RestartRandomNodeAbort", 120) != 0){
  533. g_err << "Failed to executeRestart(RestartRandomNode)"<<endl;
  534. result = NDBT_FAILED;
  535. goto end_test;
  536.       }
  537.     } else {
  538.       // Restart all nodes
  539.       ndbout << "Restart all nodes " << endl;
  540.       if(restarts.executeRestart("RestartAllNodesAbort", 120) != 0){
  541. g_err << "Failed to executeRestart(RestartAllNodes)"<<endl;
  542. result = NDBT_FAILED;
  543. goto end_test;
  544.       }
  545.     }
  546.     
  547.     // Delete the ndb objects
  548.     for(size_t j = 0;  j < ndbVector.size(); j++)
  549.       delete ndbVector[j];
  550.     ndbVector.clear();
  551.     l++;
  552.   }
  553.   
  554.   
  555.  end_test:
  556.   
  557.   for(size_t i = 0;  i < ndbVector.size(); i++)
  558.     delete ndbVector[i];
  559.   ndbVector.clear();
  560.   
  561.   return result;
  562. }
  565. int runClearTable(NDBT_Context* ctx, NDBT_Step* step){
  566.   int records = ctx->getNumRecords();
  567.   
  568.   UtilTransactions utilTrans(*ctx->getTab());
  569.   if (utilTrans.clearTable2(GETNDB(step),  records) != 0){
  570.     return NDBT_FAILED;
  571.   }
  572.   return NDBT_OK;
  573. }
  574. int runLoadTable(NDBT_Context* ctx, NDBT_Step* step){
  576.   int records = ctx->getNumRecords();
  577.   HugoTransactions hugoTrans(*ctx->getTab());
  578.   if (hugoTrans.loadTable(GETNDB(step), records) != 0){
  579.     return NDBT_FAILED;
  580.   }
  581.   return NDBT_OK;
  582. }
  584. int runTestWaitUntilReady(NDBT_Context* ctx, NDBT_Step* step){
  586.   Ndb* pNdb = new Ndb("TEST_DB");
  588.   // Forget about calling pNdb->init();
  590.   if (pNdb->waitUntilReady() == 0){
  591.     ndbout << "waitUntilReady returned OK" << endl;
  592.     delete pNdb;
  593.     return NDBT_FAILED;
  594.   }
  595.   const NdbError err = pNdb->getNdbError();
  596.   delete pNdb;
  598.   ERR(err);
  599.   if (err.code != 4256)
  600.     return NDBT_FAILED;
  601.   
  602.   return NDBT_OK;
  603. }
  605. int runGetNdbOperationNoTab(NDBT_Context* ctx, NDBT_Step* step){
  607.   Ndb* pNdb = new Ndb("TEST_DB");
  608.   if (pNdb == NULL){
  609.     ndbout << "pNdb == NULL" << endl;      
  610.     return NDBT_FAILED;  
  611.   }
  612.   if (pNdb->init()){
  613.     ERR(pNdb->getNdbError());
  614.     delete pNdb;
  615.     return NDBT_FAILED;
  616.   }
  617.   
  618.   NdbConnection* pCon = pNdb->startTransaction();
  619.   if (pCon == NULL){
  620.     delete pNdb;
  621.     return NDBT_FAILED;
  622.   }
  623.   
  624.   // Call getNdbOperation on an unknown table
  625.   NdbOperation* pOp = pCon->getNdbOperation("HUPP76");
  626.   if (pOp == NULL){
  627.     NdbError err = pCon->getNdbError();
  628.     ERR(err);
  629.     if (err.code == 0){
  630.       pNdb->closeTransaction(pCon);
  631.       delete pNdb;
  632.       return NDBT_FAILED;
  633.     }    
  634.   }
  635.         
  636.   pNdb->closeTransaction(pCon);
  637.     
  638.   delete pNdb;
  640.   return NDBT_OK;
  641. }
  643. int runMissingOperation(NDBT_Context* ctx, NDBT_Step* step){
  644.   int result = NDBT_OK;
  645.   const NdbDictionary::Table* pTab = ctx->getTab();
  648.   Ndb* pNdb = new Ndb("TEST_DB");
  649.   if (pNdb == NULL){
  650.     ndbout << "pNdb == NULL" << endl;      
  651.     return NDBT_FAILED;  
  652.   }
  653.   if (pNdb->init()){
  654.     ERR(pNdb->getNdbError());
  655.     delete pNdb;
  656.     return NDBT_FAILED;
  657.   }
  658.   
  659.   NdbConnection* pCon = pNdb->startTransaction();
  660.   if (pCon == NULL){
  661.     pNdb->closeTransaction(pCon);  
  662.     delete pNdb;
  663.     return NDBT_FAILED;
  664.   }
  665.     
  666.   NdbOperation* pOp = pCon->getNdbOperation(pTab->getName());
  667.   if (pOp == NULL){
  668.     ERR(pCon->getNdbError());
  669.     pNdb->closeTransaction(pCon);  
  670.     delete pNdb;
  671.     return NDBT_FAILED;
  672.   }
  673.   
  674.   // Forget about calling pOp->insertTuple();
  675.   
  676.   // Call getValue should not work
  677.   if (pOp->getValue(pTab->getColumn(1)->getName()) == NULL) {
  678.     const NdbError err = pCon->getNdbError();
  679.     ERR(err);
  680.     if (err.code == 0){
  681.       ndbout << "hupp" << endl;
  682.       result = NDBT_FAILED;
  683.     }
  684.   } else {
  685.       ndbout << "hupp2" << endl;
  686.     result = NDBT_FAILED;
  687.   }
  688.       
  689.   pNdb->closeTransaction(pCon);  
  690.   delete pNdb;
  692.   return result;
  693. }
  695. int runGetValueInUpdate(NDBT_Context* ctx, NDBT_Step* step){
  696.   const NdbDictionary::Table* pTab = ctx->getTab();
  698.   Ndb* pNdb = new Ndb("TEST_DB");
  699.   if (pNdb == NULL){
  700.     ndbout << "pNdb == NULL" << endl;      
  701.     return NDBT_FAILED;  
  702.   }
  703.   if (pNdb->init()){
  704.     ERR(pNdb->getNdbError());
  705.     delete pNdb;
  706.     return NDBT_FAILED;
  707.   }
  708.   
  709.   NdbConnection* pCon = pNdb->startTransaction();
  710.   if (pCon == NULL){
  711.     pNdb->closeTransaction(pCon);  
  712.     delete pNdb;
  713.     return NDBT_FAILED;
  714.   }
  715.     
  716.   NdbOperation* pOp = pCon->getNdbOperation(pTab->getName());
  717.   if (pOp == NULL){
  718.     ERR(pCon->getNdbError());
  719.     pNdb->closeTransaction(pCon);  
  720.     delete pNdb;
  721.     return NDBT_FAILED;
  722.   }
  723.   
  724.   if (pOp->updateTuple() != 0){
  725.     pNdb->closeTransaction(pCon);
  726.     delete pNdb;
  727.     return NDBT_FAILED;
  728.   }
  729.   
  730.   // Call getValue should not work
  731.   if (pOp->getValue(pTab->getColumn(1)->getName()) == NULL) {
  732.     // It didn't work
  733.     const NdbError err = pCon->getNdbError();
  734.     ERR(err);
  735.     if (err.code == 0){
  736.       pNdb->closeTransaction(pCon);  
  737.       delete pNdb;
  738.       return NDBT_FAILED;
  739.     }
  740.   } else {
  741.     // It worked, not good!
  742.     pNdb->closeTransaction(pCon);  
  743.     delete pNdb;    
  744.     return NDBT_FAILED;
  745.   }
  747.   int check = pCon->execute(Commit);
  748.   if (check != 0){
  749.     ERR(pCon->getNdbError());
  750.   }
  751.   
  752.   pNdb->closeTransaction(pCon);  
  753.   delete pNdb;
  755.   return NDBT_OK;
  756. }
  758. int runUpdateWithoutValues(NDBT_Context* ctx, NDBT_Step* step){
  759.   int result = NDBT_OK;
  760.   const NdbDictionary::Table* pTab = ctx->getTab();
  762.   HugoOperations hugoOps(*pTab);
  764.   Ndb* pNdb = new Ndb("TEST_DB");
  765.   if (pNdb == NULL){
  766.     ndbout << "pNdb == NULL" << endl;      
  767.     return NDBT_FAILED;  
  768.   }
  769.   if (pNdb->init()){
  770.     ERR(pNdb->getNdbError());
  771.     delete pNdb;
  772.     return NDBT_FAILED;
  773.   }
  774.   
  775.   NdbConnection* pCon = pNdb->startTransaction();
  776.   if (pCon == NULL){
  777.     pNdb->closeTransaction(pCon);  
  778.     delete pNdb;
  779.     return NDBT_FAILED;
  780.   }
  781.     
  782.   NdbOperation* pOp = pCon->getNdbOperation(pTab->getName());
  783.   if (pOp == NULL){
  784.     ERR(pCon->getNdbError());
  785.     pNdb->closeTransaction(pCon);  
  786.     delete pNdb;
  787.     return NDBT_FAILED;
  788.   }
  789.   
  790.   if (pOp->updateTuple() != 0){
  791.     pNdb->closeTransaction(pCon);
  792.     ERR(pOp->getNdbError());
  793.     delete pNdb;
  794.     return NDBT_FAILED;
  795.   }
  797.   for(int a = 0; a<pTab->getNoOfColumns(); a++){
  798.     if (pTab->getColumn(a)->getPrimaryKey() == true){
  799.       if(hugoOps.equalForAttr(pOp, a, 1) != 0){
  800. ERR(pCon->getNdbError());
  801. pNdb->closeTransaction(pCon);
  802. delete pNdb;
  803. return NDBT_FAILED;
  804.       }
  805.     }
  806.   }
  808.   // Dont' call any setValues
  810.   // Execute should not work
  811.   int check = pCon->execute(Commit);
  812.   if (check == 0){
  813.     ndbout << "execute worked" << endl;
  814.     result = NDBT_FAILED;
  815.   } else {
  816.     ERR(pCon->getNdbError());
  817.   }
  818.   
  819.   pNdb->closeTransaction(pCon);  
  820.   delete pNdb;
  822.   return result;
  823. }
  825. int runUpdateWithoutKeys(NDBT_Context* ctx, NDBT_Step* step){
  826.   int result = NDBT_OK;
  827.   const NdbDictionary::Table* pTab = ctx->getTab();
  830.   Ndb* pNdb = new Ndb("TEST_DB");
  831.   if (pNdb == NULL){
  832.     ndbout << "pNdb == NULL" << endl;      
  833.     return NDBT_FAILED;  
  834.   }
  835.   if (pNdb->init()){
  836.     ERR(pNdb->getNdbError());
  837.     delete pNdb;
  838.     return NDBT_FAILED;
  839.   }
  840.   
  841.   NdbConnection* pCon = pNdb->startTransaction();
  842.   if (pCon == NULL){
  843.     pNdb->closeTransaction(pCon);  
  844.     delete pNdb;
  845.     return NDBT_FAILED;
  846.   }
  847.     
  848.   NdbOperation* pOp = pCon->getNdbOperation(pTab->getName());
  849.   if (pOp == NULL){
  850.     ERR(pCon->getNdbError());
  851.     pNdb->closeTransaction(pCon);  
  852.     delete pNdb;
  853.     return NDBT_FAILED;
  854.   }
  855.   
  856.   if (pOp->updateTuple() != 0){
  857.     pNdb->closeTransaction(pCon);
  858.     ERR(pOp->getNdbError());
  859.     delete pNdb;
  860.     return NDBT_FAILED;
  861.   }
  863.   // Dont' call any equal or setValues
  865.   // Execute should not work
  866.   int check = pCon->execute(Commit);
  867.   if (check == 0){
  868.     ndbout << "execute worked" << endl;
  869.     result = NDBT_FAILED;
  870.   } else {
  871.     ERR(pCon->getNdbError());
  872.   }
  873.   
  874.   pNdb->closeTransaction(pCon);  
  875.   delete pNdb;
  877.   return result;
  878. }
  881. int runReadWithoutGetValue(NDBT_Context* ctx, NDBT_Step* step){
  882.   int result = NDBT_OK;
  883.   const NdbDictionary::Table* pTab = ctx->getTab();
  885.   HugoOperations hugoOps(*pTab);
  887.   Ndb* pNdb = GETNDB(step);
  888.   Uint32 lm;
  890.   for(Uint32 cm= 0; cm < 2; cm++)
  891.   {
  892.     for(lm= 0; lm <= NdbOperation::LM_CommittedRead; lm++)
  893.     {
  894.       NdbConnection* pCon = pNdb->startTransaction();
  895.       if (pCon == NULL){
  896. pNdb->closeTransaction(pCon);  
  897. return NDBT_FAILED;
  898.       }
  899.     
  900.       NdbOperation* pOp = pCon->getNdbOperation(pTab->getName());
  901.       if (pOp == NULL){
  902. ERR(pCon->getNdbError());
  903. pNdb->closeTransaction(pCon);  
  904. return NDBT_FAILED;
  905.       }
  906.   
  907.       if (pOp->readTuple((NdbOperation::LockMode)lm) != 0){
  908. pNdb->closeTransaction(pCon);
  909. ERR(pOp->getNdbError());
  910. return NDBT_FAILED;
  911.       }
  912.     
  913.       for(int a = 0; a<pTab->getNoOfColumns(); a++){
  914. if (pTab->getColumn(a)->getPrimaryKey() == true){
  915.   if(hugoOps.equalForAttr(pOp, a, 1) != 0){
  916.     ERR(pCon->getNdbError());
  917.     pNdb->closeTransaction(pCon);
  918.     return NDBT_FAILED;
  919.   }
  920. }
  921.       }
  922.     
  923.       // Dont' call any getValues
  924.     
  925.       // Execute should work
  926.       int check = pCon->execute(cm == 0 ? NoCommit : Commit);
  927.       if (check == 0){
  928. ndbout << "execute worked" << endl;
  929.       } else {
  930. ERR(pCon->getNdbError());
  931. result = NDBT_FAILED;
  932.       }
  933.     
  934.       pNdb->closeTransaction(pCon);  
  935.     }
  936.   }
  938.   /**
  939.    * Now test scans
  940.    */
  941.   for(lm= 0; lm <= NdbOperation::LM_CommittedRead; lm++)
  942.   {
  943.     NdbConnection* pCon = pNdb->startTransaction();
  944.     if (pCon == NULL){
  945.       pNdb->closeTransaction(pCon);  
  946.       return NDBT_FAILED;
  947.     }
  948.     
  949.     NdbScanOperation* pOp = pCon->getNdbScanOperation(pTab->getName());
  950.     if (pOp == NULL){
  951.       ERR(pCon->getNdbError());
  952.       pNdb->closeTransaction(pCon);  
  953.       return NDBT_FAILED;
  954.     }
  955.     
  956.     NdbResultSet *rs;
  957.     if ((rs = pOp->readTuples((NdbOperation::LockMode)lm)) == 0){
  958.       pNdb->closeTransaction(pCon);
  959.       ERR(pOp->getNdbError());
  960.       return NDBT_FAILED;
  961.     }
  962.     
  963.     
  964.     // Dont' call any getValues
  965.     
  966.     // Execute should work
  967.     int check = pCon->execute(NoCommit);
  968.     if (check == 0){
  969.       ndbout << "execute worked" << endl;
  970.     } else {
  971.       ERR(pCon->getNdbError());
  972.       result = NDBT_FAILED;
  973.     }
  974.   
  975.     int res;
  976.     while((res = rs->nextResult()) == 0);
  977.     pNdb->closeTransaction(pCon);  
  978.     
  979.     if(res != 1)
  980.       result = NDBT_FAILED;
  981.   }
  982.   
  983.   return result;
  984. }
  987. int runCheckGetNdbErrorOperation(NDBT_Context* ctx, NDBT_Step* step){
  988.   int result = NDBT_OK;
  989.   const NdbDictionary::Table* pTab = ctx->getTab();
  991.   Ndb* pNdb = new Ndb("TEST_DB");
  992.   if (pNdb == NULL){
  993.     ndbout << "pNdb == NULL" << endl;      
  994.     return NDBT_FAILED;  
  995.   }
  996.   if (pNdb->init(2048)){
  997.     ERR(pNdb->getNdbError());
  998.     delete pNdb;
  999.     return NDBT_FAILED;
  1000.   }
  1002.   HugoOperations hugoOps(*pTab);
  1003.   
  1004.   
  1005.   NdbConnection* pCon = pNdb->startTransaction();
  1006.   if (pCon == NULL){
  1007.     ndbout << "Could not start transaction" << endl;
  1008.     delete pNdb;
  1009.     return NDBT_FAILED;
  1010.   }
  1011.   
  1012.   NdbOperation* pOp = pCon->getNdbOperation(pTab->getName());
  1013.   if (pOp == NULL){
  1014.     ERR(pCon->getNdbError());
  1015.     pNdb->closeTransaction(pCon);
  1016.     delete pNdb;
  1017.     return NDBT_FAILED;
  1018.   }
  1019.   
  1020.   // Dont call readTuple here
  1021.   // That's the error!
  1022.   
  1023.   for(int a = 0; a<pTab->getNoOfColumns(); a++){
  1024.     if (pTab->getColumn(a)->getPrimaryKey() == true){
  1025.       if(hugoOps.equalForAttr(pOp, a, 1) != 0){
  1026. // An error has occured, check that 
  1027. // it's possible to get the NdbErrorOperation
  1028. const NdbError err = pCon->getNdbError();
  1029. ERR(err);
  1030. if (err.code == 0)
  1031.   result = NDBT_FAILED;
  1033. NdbOperation* pOp2 = pCon->getNdbErrorOperation();
  1034. if (pOp2 == NULL)
  1035.   result = NDBT_FAILED;
  1036. else {
  1037.   const NdbError err2 = pOp2->getNdbError();
  1038.   ERR(err2);
  1039.   if (err.code == 0)
  1040.     result = NDBT_FAILED;
  1041. }
  1042.       }
  1043.     }
  1044.   }
  1045.   
  1046.   pNdb->closeTransaction(pCon);
  1047.     
  1048.   delete pNdb;
  1049.   return result;
  1050. }
  1052. #define C2(x) { int _x= (x); if(_x == 0) return NDBT_FAILED; }
  1054. int runBug_11133(NDBT_Context* ctx, NDBT_Step* step){
  1055.   int result = NDBT_OK;
  1056.   const NdbDictionary::Table* pTab = ctx->getTab();
  1058.   HugoOperations hugoOps(*pTab);
  1060.   Ndb* pNdb = GETNDB(step);
  1062.   C2(hugoOps.startTransaction(pNdb) == 0);
  1063.   C2(hugoOps.pkInsertRecord(pNdb, 0, 1) == 0);
  1064.   C2(hugoOps.execute_NoCommit(pNdb) == 0);
  1065.   C2(hugoOps.pkDeleteRecord(pNdb, 0, 1) == 0);
  1066.   C2(hugoOps.execute_NoCommit(pNdb) == 0);
  1067.   C2(hugoOps.pkWriteRecord(pNdb, 0, 1) == 0);
  1068.   C2(hugoOps.execute_NoCommit(pNdb) == 0);
  1069.   C2(hugoOps.pkWriteRecord(pNdb, 0, 1) == 0);
  1070.   C2(hugoOps.execute_NoCommit(pNdb) == 0);
  1071.   C2(hugoOps.pkDeleteRecord(pNdb, 0, 1) == 0);
  1072.   C2(hugoOps.execute_Commit(pNdb) == 0);
  1073.   C2(hugoOps.closeTransaction(pNdb) == 0);
  1075.   C2(hugoOps.startTransaction(pNdb) == 0);
  1076.   C2(hugoOps.pkInsertRecord(pNdb, 0, 1) == 0);
  1077.   C2(hugoOps.execute_NoCommit(pNdb) == 0);
  1078.   C2(hugoOps.pkWriteRecord(pNdb, 0, 1) == 0);
  1079.   C2(hugoOps.execute_NoCommit(pNdb) == 0);
  1080.   C2(hugoOps.pkWriteRecord(pNdb, 0, 1) == 0);
  1081.   C2(hugoOps.execute_NoCommit(pNdb) == 0);
  1082.   C2(hugoOps.pkDeleteRecord(pNdb, 0, 1) == 0);
  1083.   C2(hugoOps.execute_Commit(pNdb) == 0);
  1084.   C2(hugoOps.closeTransaction(pNdb) == 0);
  1086.   C2(hugoOps.startTransaction(pNdb) == 0);
  1087.   C2(hugoOps.pkInsertRecord(pNdb, 0, 1) == 0);
  1088.   C2(hugoOps.execute_Commit(pNdb) == 0);
  1089.   C2(hugoOps.closeTransaction(pNdb) == 0);
  1091.   C2(hugoOps.startTransaction(pNdb) == 0);
  1092.   C2(hugoOps.pkReadRecord(pNdb, 0, 1, NdbOperation::LM_Exclusive) == 0);
  1093.   C2(hugoOps.execute_NoCommit(pNdb) == 0);
  1094.   C2(hugoOps.pkDeleteRecord(pNdb, 0, 1) == 0);
  1095.   C2(hugoOps.execute_NoCommit(pNdb) == 0);
  1096.   C2(hugoOps.pkWriteRecord(pNdb, 0, 1) == 0);
  1097.   C2(hugoOps.execute_NoCommit(pNdb) == 0);
  1098.   C2(hugoOps.pkWriteRecord(pNdb, 0, 1) == 0);
  1099.   C2(hugoOps.execute_NoCommit(pNdb) == 0);
  1100.   C2(hugoOps.pkDeleteRecord(pNdb, 0, 1) == 0);
  1101.   C2(hugoOps.execute_Commit(pNdb) == 0);
  1102.   C2(hugoOps.closeTransaction(pNdb) == 0);
  1104.   Ndb ndb2("TEST_DB");
  1105.   C2(ndb2.init() == 0);
  1106.   C2(ndb2.waitUntilReady() == 0);
  1107.   HugoOperations hugoOps2(*pTab);  
  1109.   C2(hugoOps.startTransaction(pNdb) == 0);
  1110.   C2(hugoOps.pkInsertRecord(pNdb, 0, 1) == 0);
  1111.   C2(hugoOps.execute_NoCommit(pNdb) == 0);
  1112.   C2(hugoOps2.startTransaction(&ndb2) == 0);
  1113.   C2(hugoOps2.pkWriteRecord(&ndb2, 0, 1) == 0);
  1114.   C2(hugoOps2.execute_async(&ndb2, NoCommit) == 0);
  1115.   C2(hugoOps.execute_Commit(pNdb) == 0);
  1116.   C2(hugoOps2.wait_async(&ndb2) == 0);
  1117.   C2(hugoOps.closeTransaction(pNdb) == 0);
  1118.   C2(hugoOps2.closeTransaction(&ndb2) == 0);  
  1120.   C2(hugoOps.startTransaction(pNdb) == 0);
  1121.   C2(hugoOps.pkDeleteRecord(pNdb, 0, 1) == 0);
  1122.   C2(hugoOps.execute_NoCommit(pNdb) == 0);
  1123.   C2(hugoOps2.startTransaction(&ndb2) == 0);
  1124.   C2(hugoOps2.pkWriteRecord(&ndb2, 0, 1) == 0);
  1125.   C2(hugoOps2.execute_async(&ndb2, NoCommit) == 0);
  1126.   C2(hugoOps.execute_Commit(pNdb) == 0);
  1127.   C2(hugoOps2.wait_async(&ndb2) == 0);
  1128.   C2(hugoOps.closeTransaction(pNdb) == 0);
  1129.   C2(hugoOps2.closeTransaction(&ndb2) == 0);  
  1131.   return result;
  1132. }
  1136. NDBT_TESTSUITE(testNdbApi);
  1137. TESTCASE("MaxNdb", 
  1138.  "Create Ndb objects until no more can be createdn"){ 
  1139.   INITIALIZER(runTestMaxNdb);
  1140. }
  1141. TESTCASE("MaxTransactions", 
  1142.  "Start transactions until no more can be createdn"){ 
  1143.   INITIALIZER(runTestMaxTransaction);
  1144. }
  1145. TESTCASE("MaxOperations", 
  1146. "Get operations until no more can be createdn"){ 
  1147.   INITIALIZER(runLoadTable);
  1148.   INITIALIZER(runTestMaxOperations);
  1149.   FINALIZER(runClearTable);
  1150. }
  1151. TESTCASE("MaxGetValue", 
  1152. "Call getValue loads of timen"){ 
  1153.   INITIALIZER(runLoadTable);
  1154.   INITIALIZER(runTestGetValue);
  1155.   FINALIZER(runClearTable);
  1156. }
  1157. TESTCASE("MaxEqual", 
  1158. "Call equal loads of timen"){ 
  1159.   INITIALIZER(runTestEqual);
  1160. }
  1161. TESTCASE("DeleteNdb", 
  1162. "Make sure that a deleted Ndb object is properly deletedn"
  1163. "and removed from transportern"){ 
  1164.   INITIALIZER(runLoadTable);
  1165.   INITIALIZER(runTestDeleteNdb);
  1166.   FINALIZER(runClearTable);
  1167. }
  1168. TESTCASE("WaitUntilReady", 
  1169. "Make sure you get an error message when calling waitUntilReadyn"
  1170. "without an init'ed Ndbn"){ 
  1171.   INITIALIZER(runTestWaitUntilReady);
  1172. }
  1173. TESTCASE("GetOperationNoTab", 
  1174. "Call getNdbOperation on a table that does not existn"){ 
  1175.   INITIALIZER(runGetNdbOperationNoTab);
  1176. }
  1177. TESTCASE("MissingOperation", 
  1178. "Missing operation request(insertTuple) should give an error coden"){ 
  1179.   INITIALIZER(runMissingOperation);
  1180. }
  1181. TESTCASE("GetValueInUpdate", 
  1182. "Test that it's not possible to perform getValue in an updaten"){ 
  1183.   INITIALIZER(runLoadTable);
  1184.   INITIALIZER(runGetValueInUpdate);
  1185.   FINALIZER(runClearTable);
  1186. }
  1187. TESTCASE("UpdateWithoutKeys", 
  1188. "Test that it's not possible to perform update without settingn"
  1189.  "PKs"){ 
  1190.   INITIALIZER(runLoadTable);
  1191.   INITIALIZER(runUpdateWithoutKeys);
  1192.   FINALIZER(runClearTable);
  1193. }
  1194. TESTCASE("UpdateWithoutValues", 
  1195. "Test that it's not possible to perform update without setValuesn"){ 
  1196.   INITIALIZER(runLoadTable);
  1197.   INITIALIZER(runUpdateWithoutValues);
  1198.   FINALIZER(runClearTable);
  1199. }
  1200. TESTCASE("NdbErrorOperation", 
  1201.  "Test that NdbErrorOperation is properly set"){
  1202.   INITIALIZER(runCheckGetNdbErrorOperation);
  1203. }
  1204. TESTCASE("ReadWithoutGetValue", 
  1205.  "Test that it's possible to perform read wo/ getvalue'sn"){ 
  1206.   INITIALIZER(runLoadTable);
  1207.   INITIALIZER(runReadWithoutGetValue);
  1208.   FINALIZER(runClearTable);
  1209. }
  1210. TESTCASE("Bug_11133", 
  1211.  "Test ReadEx-Delete-Writen"){ 
  1212.   INITIALIZER(runBug_11133);
  1213.   FINALIZER(runClearTable);
  1214. }
  1215. NDBT_TESTSUITE_END(testNdbApi);
  1217. int main(int argc, const char** argv){
  1218.   ndb_init();
  1219.   //  TABLE("T1");
  1220.   return testNdbApi.execute(argc, argv);
  1221. }
  1223. template class Vector<Ndb*>;
  1224. template class Vector<NdbConnection*>;