testDict.cpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:46k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #include <NDBT.hpp>
  14. #include <NDBT_Test.hpp>
  15. #include <HugoTransactions.hpp>
  16. #include <UtilTransactions.hpp>
  17. #include <NdbRestarter.hpp>
  18. #include <Vector.hpp>
  19. #include <signaldata/DumpStateOrd.hpp>
  20. #include <../../include/kernel/ndb_limits.h>
  21. #include <random.h>
  22. #include <NdbAutoPtr.hpp>
  23.  
  24. #define CHECK(b) if (!(b)) { 
  25.   g_err << "ERR: "<< step->getName() 
  26.          << " failed on line " << __LINE__ << endl; 
  27.   result = NDBT_FAILED; 
  28.   break; } 
  29. #define CHECK2(b, c) if (!(b)) { 
  30.   g_err << "ERR: "<< step->getName() 
  31.          << " failed on line " << __LINE__ << ": " << c << endl; 
  32.   result = NDBT_FAILED; 
  33.   goto end; }
  34. int runLoadTable(NDBT_Context* ctx, NDBT_Step* step){
  35.   Ndb* pNdb = GETNDB(step);
  36.   int records = ctx->getNumRecords();
  37.   HugoTransactions hugoTrans(*ctx->getTab());
  38.   if (hugoTrans.loadTable(pNdb, records) != 0){
  39.     return NDBT_FAILED;
  40.   }
  41.   return NDBT_OK;
  42. }
  43. int runCreateInvalidTables(NDBT_Context* ctx, NDBT_Step* step){
  44.   Ndb* pNdb = GETNDB(step);
  45.   int result = NDBT_OK;
  46.   char failTabName[256];
  47.   for (int i = 0; i < 10; i++){
  48.     BaseString::snprintf(failTabName, 256, "F%d", i);
  49.   
  50.     const NdbDictionary::Table* pFailTab = NDBT_Tables::getTable(failTabName);
  51.     if (pFailTab != NULL){
  52.       ndbout << "|- " << failTabName << endl;
  53.       // Try to create table in db
  54.       if (pFailTab->createTableInDb(pNdb) == 0){
  55.         ndbout << failTabName << " created, this was not expected"<< endl;
  56.         result = NDBT_FAILED;
  57.       }
  58.       // Verify that table is not in db    
  59.       const NdbDictionary::Table* pTab2 = 
  60. NDBT_Table::discoverTableFromDb(pNdb, failTabName) ;
  61.       if (pTab2 != NULL){
  62.         ndbout << failTabName << " was found in DB, this was not expected"<< endl;
  63.         result = NDBT_FAILED;
  64. if (pFailTab->equal(*pTab2) == true){
  65.   ndbout << "It was equal" << endl;
  66. } else {
  67.   ndbout << "It was not equal" << endl;
  68. }
  69. int records = 1000;
  70. HugoTransactions hugoTrans(*pTab2);
  71. if (hugoTrans.loadTable(pNdb, records) != 0){
  72.   ndbout << "It can NOT be loaded" << endl;
  73. } else{
  74.   ndbout << "It can be loaded" << endl;
  75.   
  76.   UtilTransactions utilTrans(*pTab2);
  77.   if (utilTrans.clearTable(pNdb, records, 64) != 0){
  78.     ndbout << "It can NOT be cleared" << endl;
  79.   } else{
  80.     ndbout << "It can be cleared" << endl;
  81.   }   
  82. }
  83. if (pNdb->getDictionary()->dropTable(pTab2->getName()) == -1){
  84.   ndbout << "It can NOT be dropped" << endl;
  85. } else {
  86.   ndbout << "It can be dropped" << endl;
  87. }
  88.       }
  89.     }
  90.   }
  91.   return result;
  92. }
  93. int runCreateTheTable(NDBT_Context* ctx, NDBT_Step* step){
  94.   Ndb* pNdb = GETNDB(step);  
  95.   const NdbDictionary::Table* pTab = ctx->getTab();
  96.   // Try to create table in db
  97.   if (pTab->createTableInDb(pNdb) != 0){
  98.     return NDBT_FAILED;
  99.   }
  100.   // Verify that table is in db     
  101.   const NdbDictionary::Table* pTab2 = 
  102.     NDBT_Table::discoverTableFromDb(pNdb, pTab->getName());
  103.   if (pTab2 == NULL){
  104.     ndbout << pTab->getName() << " was not found in DB"<< endl;
  105.     return NDBT_FAILED;
  106.   }
  107.   ctx->setTab(pTab2);
  108.   return NDBT_OK;
  109. }
  110. int runCreateTableWhenDbIsFull(NDBT_Context* ctx, NDBT_Step* step){
  111.   Ndb* pNdb = GETNDB(step);
  112.   int result = NDBT_OK;
  113.   const char* tabName = "TRANSACTION"; //Use a util table
  114.   
  115.   const NdbDictionary::Table* pTab = NDBT_Tables::getTable(tabName);
  116.   if (pTab != NULL){
  117.     ndbout << "|- " << tabName << endl;
  118.     
  119.     // Verify that table is not in db     
  120.     if (NDBT_Table::discoverTableFromDb(pNdb, tabName) != NULL){
  121.       ndbout << tabName << " was found in DB"<< endl;
  122.       return NDBT_FAILED;
  123.     }
  124.     // Try to create table in db
  125.     if (pTab->createTableInDb(pNdb) == 0){
  126.       result = NDBT_FAILED;
  127.     }
  128.     // Verify that table is in db     
  129.     if (NDBT_Table::discoverTableFromDb(pNdb, tabName) != NULL){
  130.       ndbout << tabName << " was found in DB"<< endl;
  131.       result = NDBT_FAILED;
  132.     }
  133.   }
  134.   return result;
  135. }
  136. int runDropTableWhenDbIsFull(NDBT_Context* ctx, NDBT_Step* step){
  137.   Ndb* pNdb = GETNDB(step);
  138.   int result = NDBT_OK;
  139.   const char* tabName = "TRANSACTION"; //Use a util table
  140.   
  141.   const NdbDictionary::Table* pTab = NDBT_Table::discoverTableFromDb(pNdb, tabName);
  142.   if (pTab != NULL){
  143.     ndbout << "|- TRANSACTION" << endl;
  144.     
  145.     // Try to drop table in db
  146.     if (pNdb->getDictionary()->dropTable(pTab->getName()) == -1){
  147.       result = NDBT_FAILED;
  148.     }
  149.     // Verify that table is not in db     
  150.     if (NDBT_Table::discoverTableFromDb(pNdb, tabName) != NULL){
  151.       ndbout << tabName << " was found in DB"<< endl;
  152.       result = NDBT_FAILED;
  153.     }
  154.   }
  155.   return result;
  156. }
  157. int runCreateAndDrop(NDBT_Context* ctx, NDBT_Step* step){
  158.   Ndb* pNdb = GETNDB(step);
  159.   int loops = ctx->getNumLoops();
  160.   int i = 0;
  161.   
  162.   const NdbDictionary::Table* pTab = ctx->getTab();
  163.   ndbout << "|- " << pTab->getName() << endl;
  164.   
  165.   while (i < loops){
  166.     ndbout << i << ": ";    
  167.     // Try to create table in db
  168.     if (pTab->createTableInDb(pNdb) != 0){
  169.       return NDBT_FAILED;
  170.     }
  171.     // Verify that table is in db     
  172.     const NdbDictionary::Table* pTab2 = 
  173.       NDBT_Table::discoverTableFromDb(pNdb, pTab->getName());
  174.     if (pTab2 == NULL){
  175.       ndbout << pTab->getName() << " was not found in DB"<< endl;
  176.       return NDBT_FAILED;
  177.     }
  178.     if (pNdb->getDictionary()->dropTable(pTab2->getName())){
  179.       ndbout << "Failed to drop "<<pTab2->getName()<<" in db" << endl;
  180.       return NDBT_FAILED;
  181.     }
  182.     
  183.     // Verify that table is not in db     
  184.     const NdbDictionary::Table* pTab3 = 
  185.       NDBT_Table::discoverTableFromDb(pNdb, pTab->getName());
  186.     if (pTab3 != NULL){
  187.       ndbout << pTab3->getName() << " was found in DB"<< endl;
  188.       return NDBT_FAILED;
  189.     }
  190.     i++;
  191.   }
  192.   return NDBT_OK;
  193. }
  194. int runCreateAndDropWithData(NDBT_Context* ctx, NDBT_Step* step){
  195.   Ndb* pNdb = GETNDB(step);
  196.   int loops = ctx->getNumLoops();
  197.   int records = ctx->getNumRecords();
  198.   int i = 0;
  199.   
  200.   NdbRestarter restarter;
  201.   int val = DumpStateOrd::DihMinTimeBetweenLCP;
  202.   if(restarter.dumpStateAllNodes(&val, 1) != 0){
  203.     int result;
  204.     do { CHECK(0); } while (0);
  205.     g_err << "Unable to change timebetween LCP" << endl;
  206.     return NDBT_FAILED;
  207.   }
  208.   
  209.   const NdbDictionary::Table* pTab = ctx->getTab();
  210.   ndbout << "|- " << pTab->getName() << endl;
  211.   
  212.   while (i < loops){
  213.     ndbout << i << ": ";
  214.     // Try to create table in db
  215.     if (pTab->createTableInDb(pNdb) != 0){
  216.       return NDBT_FAILED;
  217.     }
  218.     // Verify that table is in db     
  219.     const NdbDictionary::Table* pTab2 = 
  220.       NDBT_Table::discoverTableFromDb(pNdb, pTab->getName());
  221.     if (pTab2 == NULL){
  222.       ndbout << pTab->getName() << " was not found in DB"<< endl;
  223.       return NDBT_FAILED;
  224.     }
  225.     HugoTransactions hugoTrans(*pTab2);
  226.     if (hugoTrans.loadTable(pNdb, records) != 0){
  227.       return NDBT_FAILED;
  228.     }
  229.     int count = 0;
  230.     UtilTransactions utilTrans(*pTab2);
  231.     if (utilTrans.selectCount(pNdb, 64, &count) != 0){
  232.       return NDBT_FAILED;
  233.     }
  234.     if (count != records){
  235.       ndbout << count <<" != "<<records << endl;
  236.       return NDBT_FAILED;
  237.     }
  238.     if (pNdb->getDictionary()->dropTable(pTab2->getName()) != 0){
  239.       ndbout << "Failed to drop "<<pTab2->getName()<<" in db" << endl;
  240.       return NDBT_FAILED;
  241.     }
  242.     
  243.     // Verify that table is not in db     
  244.     const NdbDictionary::Table* pTab3 = 
  245.       NDBT_Table::discoverTableFromDb(pNdb, pTab->getName());
  246.     if (pTab3 != NULL){
  247.       ndbout << pTab3->getName() << " was found in DB"<< endl;
  248.       return NDBT_FAILED;
  249.     }
  250.     
  251.     i++;
  252.   }
  253.   return NDBT_OK;
  254. }
  255. int runFillTable(NDBT_Context* ctx, NDBT_Step* step){
  256.   Ndb* pNdb = GETNDB(step);
  257.   HugoTransactions hugoTrans(*ctx->getTab());
  258.   if (hugoTrans.fillTable(pNdb) != 0){
  259.     return NDBT_FAILED;
  260.   }
  261.   return NDBT_OK;
  262. }
  263. int runClearTable(NDBT_Context* ctx, NDBT_Step* step){
  264.   Ndb* pNdb = GETNDB(step);
  265.   int records = ctx->getNumRecords();
  266.   
  267.   UtilTransactions utilTrans(*ctx->getTab());
  268.   if (utilTrans.clearTable(pNdb,  records) != 0){
  269.     return NDBT_FAILED;
  270.   }
  271.   return NDBT_OK;
  272. }
  273. int runCreateAndDropDuring(NDBT_Context* ctx, NDBT_Step* step){
  274.   int result = NDBT_OK;
  275.   int loops = ctx->getNumLoops();
  276.   int i = 0;
  277.   
  278.   const NdbDictionary::Table* pTab = ctx->getTab();
  279.   ndbout << "|- " << pTab->getName() << endl;
  280.   
  281.   while (i < loops && result == NDBT_OK){
  282.     ndbout << i << ": " << endl;    
  283.     // Try to create table in db
  284.     Ndb* pNdb = GETNDB(step);
  285.     g_debug << "Creating table" << endl;
  286.     if (pTab->createTableInDb(pNdb) != 0){
  287.       g_err << "createTableInDb failed" << endl;
  288.       result =  NDBT_FAILED;
  289.       continue;
  290.     }
  291.     
  292.     g_debug << "Verifying creation of table" << endl;
  293.     // Verify that table is in db     
  294.     const NdbDictionary::Table* pTab2 = 
  295.       NDBT_Table::discoverTableFromDb(pNdb, pTab->getName());
  296.     if (pTab2 == NULL){
  297.       g_err << pTab->getName() << " was not found in DB"<< endl;
  298.       result =  NDBT_FAILED;
  299.       continue;
  300.     }
  301.     
  302.     NdbSleep_MilliSleep(3000);
  303.     g_debug << "Dropping table" << endl;
  304.     if (pNdb->getDictionary()->dropTable(pTab2->getName()) != 0){
  305.       g_err << "Failed to drop "<<pTab2->getName()<<" in db" << endl;
  306.       result =  NDBT_FAILED;
  307.       continue;
  308.     }
  309.     
  310.     g_debug << "Verifying dropping of table" << endl;
  311.     // Verify that table is not in db     
  312.     const NdbDictionary::Table* pTab3 = 
  313.       NDBT_Table::discoverTableFromDb(pNdb, pTab->getName());
  314.     if (pTab3 != NULL){
  315.       g_err << pTab3->getName() << " was found in DB"<< endl;
  316.       result =  NDBT_FAILED;
  317.       continue;
  318.     }
  319.     i++;
  320.   }
  321.   ctx->stopTest();
  322.   
  323.   return result;
  324. }
  325. int runUseTableUntilStopped(NDBT_Context* ctx, NDBT_Step* step){
  326.   int records = ctx->getNumRecords();
  327.   const NdbDictionary::Table* pTab = ctx->getTab();
  328.   while (ctx->isTestStopped() == false) {
  329.     //    g_info << i++ << ": ";    
  330.     // Delete and recreate Ndb object
  331.     // Otherwise you always get Invalid Schema Version
  332.     // It would be a nice feature to remove this two lines
  333.     //step->tearDown();
  334.     //step->setUp();
  335.     Ndb* pNdb = GETNDB(step);
  336.     const NdbDictionary::Table* pTab2 = 
  337.       NDBT_Table::discoverTableFromDb(pNdb, pTab->getName());
  338.     if (pTab2 == NULL)
  339.       continue;
  340.     int res;
  341.     HugoTransactions hugoTrans(*pTab2);
  342.     if ((res = hugoTrans.loadTable(pNdb, records)) != 0){
  343.       NdbError err = pNdb->getNdbError(res);
  344.       if(err.classification == NdbError::SchemaError){
  345. pNdb->getDictionary()->invalidateTable(pTab->getName());
  346.       }
  347.       continue;
  348.     }
  349.     
  350.     UtilTransactions utilTrans(*pTab2);
  351.     if ((res = utilTrans.clearTable(pNdb,  records)) != 0){
  352.       NdbError err = pNdb->getNdbError(res);
  353.       if(err.classification == NdbError::SchemaError){
  354. pNdb->getDictionary()->invalidateTable(pTab->getName());
  355.       }
  356.       continue;
  357.     }
  358.   }
  359.   g_info << endl;
  360.   return NDBT_OK;
  361. }
  362. int runCreateMaxTables(NDBT_Context* ctx, NDBT_Step* step){
  363.   int failures = 0;
  364.   char tabName[256];
  365.   int numTables = ctx->getProperty("tables", 1000);
  366.   Ndb* pNdb = GETNDB(step);
  367.   for (int i = 0; i < numTables && failures < 5; i++){
  368.     BaseString::snprintf(tabName, 256, "MAXTAB%d", i);
  369.     if (pNdb->waitUntilReady(30) != 0){
  370.       // Db is not ready, return with failure
  371.       return NDBT_FAILED;
  372.     }
  373.   
  374.     const NdbDictionary::Table* pTab = ctx->getTab();
  375.     ndbout << "|- " << tabName << endl;
  376.     // Set new name for T1
  377.     NdbDictionary::Table newTab(* pTab);
  378.     newTab.setName(tabName);
  379.     // Try to create table in db
  380.     if (newTab.createTableInDb(pNdb) != 0){
  381.       ndbout << tabName << " coult not be created"<< endl;
  382.       failures++;
  383.       continue;
  384.     }
  385.     
  386.     // Verify that table exists in db    
  387.     const NdbDictionary::Table* pTab3 = 
  388.       NDBT_Table::discoverTableFromDb(pNdb, tabName) ;
  389.     if (pTab3 == NULL){
  390.       ndbout << tabName << " was not found in DB"<< endl;
  391.       failures++;
  392.       continue;
  393.     }
  394.     
  395.     if (pTab->equal(*pTab3) == false){
  396.       ndbout << "It was not equal" << endl;
  397.       failures++;
  398.     }
  399.     int records = 1000;
  400.     HugoTransactions hugoTrans(*pTab3);
  401.     if (hugoTrans.loadTable(pNdb, records) != 0){
  402.       ndbout << "It can NOT be loaded" << endl;
  403.     } else{
  404.       ndbout << "It can be loaded" << endl;
  405.       
  406.       UtilTransactions utilTrans(*pTab3);
  407.       if (utilTrans.clearTable(pNdb, records, 64) != 0){
  408. ndbout << "It can NOT be cleared" << endl;
  409.       } else{
  410. ndbout << "It can be cleared" << endl;
  411.       }   
  412.     }
  413.     
  414.   }
  415.   if (pNdb->waitUntilReady(30) != 0){
  416.     // Db is not ready, return with failure
  417.     return NDBT_FAILED;
  418.   }
  419.   // HURRAAA!
  420.   return NDBT_OK;
  421. }
  422. int runDropMaxTables(NDBT_Context* ctx, NDBT_Step* step){
  423.   int result = NDBT_OK;
  424.   char tabName[256];
  425.   int numTables = ctx->getProperty("tables", 1000);
  426.   Ndb* pNdb = GETNDB(step);
  427.   for (int i = 0; i < numTables; i++){
  428.     BaseString::snprintf(tabName, 256, "MAXTAB%d", i);
  429.     if (pNdb->waitUntilReady(30) != 0){
  430.       // Db is not ready, return with failure
  431.       return NDBT_FAILED;
  432.     }
  433.   
  434.     // Verify that table exists in db    
  435.     const NdbDictionary::Table* pTab3 = 
  436.       NDBT_Table::discoverTableFromDb(pNdb, tabName) ;
  437.     if (pTab3 == NULL){
  438.       ndbout << tabName << " was not found in DB"<< endl;
  439.       continue;
  440.     }
  441.     // Try to drop table in db
  442.     if (pNdb->getDictionary()->dropTable(pTab3->getName()) != 0){
  443.       ndbout << tabName << " coult not be dropped"<< endl;
  444.       result = NDBT_FAILED;
  445.     }
  446.     
  447.   }
  448.   return result;
  449. }
  450. int runTestFragmentTypes(NDBT_Context* ctx, NDBT_Step* step){
  451.   int records = ctx->getNumRecords();
  452.   int fragTtype = ctx->getProperty("FragmentType");
  453.   Ndb* pNdb = GETNDB(step);
  454.   int result = NDBT_OK;
  455.   NdbRestarter restarter;
  456.   // enum FragmentType { 
  457.   //  Unknown = 0,
  458.   //  Single = 1,     ///< Only one fragment
  459.   //  All = 2,        ///< Default value.  One fragment per node group
  460.   //  AllLarge = 3    ///< Sixten fragments per node group.
  461.   // };
  462.   
  463.   if (pNdb->waitUntilReady(30) != 0){
  464.     // Db is not ready, return with failure
  465.     return NDBT_FAILED;
  466.   }
  467.   
  468.   const NdbDictionary::Table* pTab = ctx->getTab();
  469.   pNdb->getDictionary()->dropTable(pTab->getName());
  470.   NdbDictionary::Table newTab(* pTab);
  471.   // Set fragment type for table    
  472.   newTab.setFragmentType((NdbDictionary::Object::FragmentType)fragTtype);
  473.   
  474.   // Try to create table in db
  475.   if (newTab.createTableInDb(pNdb) != 0){
  476.     ndbout << newTab.getName() << " could not be created"
  477.    << ", fragmentType = "<<fragTtype <<endl;
  478.     return NDBT_FAILED;
  479.   }
  480.   
  481.   // Verify that table exists in db    
  482.   const NdbDictionary::Table* pTab3 = 
  483.     NDBT_Table::discoverTableFromDb(pNdb, pTab->getName()) ;
  484.   if (pTab3 == NULL){
  485.     ndbout << pTab->getName() << " was not found in DB"<< endl;
  486.     return NDBT_FAILED;
  487.     
  488.   }
  489.   
  490.   if (pTab3->getFragmentType() != fragTtype){
  491.     ndbout << pTab->getName() << " fragmentType error "<< endl;
  492.     result = NDBT_FAILED;
  493.     goto drop_the_tab;
  494.   }
  495.   
  496.   if (newTab.equal(*pTab3) == false){
  497.     ndbout << "It was not equal" << endl;
  498.     result = NDBT_FAILED;
  499.     goto drop_the_tab;
  500.   } 
  501.   
  502.   do {
  503.     
  504.     HugoTransactions hugoTrans(*pTab3);
  505.     UtilTransactions utilTrans(*pTab3);
  506.     int count;
  507.     CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  508.     CHECK(hugoTrans.pkUpdateRecords(pNdb, records) == 0);
  509.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  510.     CHECK(count == records);
  511.     CHECK(hugoTrans.pkDelRecords(pNdb, records/2) == 0);
  512.     CHECK(hugoTrans.scanUpdateRecords(pNdb, records) == 0);
  513.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  514.     CHECK(count == (records/2));
  515.     // restart all
  516.     ndbout << "Restarting cluster" << endl;
  517.     CHECK(restarter.restartAll() == 0);
  518.     int timeout = 120;
  519.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  520.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  521.     // Verify content
  522.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  523.     CHECK(count == (records/2));
  524.     CHECK(utilTrans.clearTable(pNdb, records) == 0);
  525.     CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  526.     CHECK(utilTrans.clearTable(pNdb, records) == 0);
  527.     CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  528.     CHECK(hugoTrans.pkUpdateRecords(pNdb, records) == 0);
  529.     CHECK(utilTrans.clearTable(pNdb, records, 64) == 0);
  530.     
  531.   } while(false);
  532.   
  533.  drop_the_tab:
  534.   
  535.   // Try to drop table in db
  536.   if (pNdb->getDictionary()->dropTable(pTab3->getName()) != 0){
  537.     ndbout << pTab3->getName()  << " could not be dropped"<< endl;
  538.     result =  NDBT_FAILED;
  539.   }
  540.   
  541.   return result;
  542. }
  543. int runTestTemporaryTables(NDBT_Context* ctx, NDBT_Step* step){
  544.   int result = NDBT_OK;
  545.   int loops = ctx->getNumLoops();
  546.   int records = ctx->getNumRecords();
  547.   Ndb* pNdb = GETNDB(step);
  548.   int i = 0;
  549.   NdbRestarter restarter;
  550.   
  551.   const NdbDictionary::Table* pTab = ctx->getTab();
  552.   ndbout << "|- " << pTab->getName() << endl;
  553.   
  554.   NdbDictionary::Table newTab(* pTab);
  555.   // Set table as temporary
  556.   newTab.setStoredTable(false);
  557.   
  558.   // Try to create table in db
  559.   if (newTab.createTableInDb(pNdb) != 0){
  560.     return NDBT_FAILED;
  561.   }
  562.   
  563.   // Verify that table is in db     
  564.   const NdbDictionary::Table* pTab2 = 
  565.     NDBT_Table::discoverTableFromDb(pNdb, pTab->getName());
  566.   if (pTab2 == NULL){
  567.     ndbout << pTab->getName() << " was not found in DB"<< endl;
  568.     return NDBT_FAILED;
  569.   }
  570.   if (pTab2->getStoredTable() != false){
  571.     ndbout << pTab->getName() << " was not temporary in DB"<< endl;
  572.     result = NDBT_FAILED;
  573.     goto drop_the_tab;
  574.   }
  575.   
  576.   while (i < loops && result == NDBT_OK){
  577.     ndbout << i << ": ";
  578.     HugoTransactions hugoTrans(*pTab2);
  579.     CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  580.     int count = 0;
  581.     UtilTransactions utilTrans(*pTab2);
  582.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  583.     CHECK(count == records);
  584.     // restart all
  585.     ndbout << "Restarting cluster" << endl;
  586.     CHECK(restarter.restartAll() == 0);
  587.     int timeout = 120;
  588.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  589.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  590.     ndbout << "Verifying records..." << endl;
  591.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  592.     CHECK(count == 0);
  593.     i++;
  594.   }
  595.  drop_the_tab:
  596.    
  597.   if (pNdb->getDictionary()->dropTable(pTab2->getName()) != 0){
  598.     ndbout << "Failed to drop "<<pTab2->getName()<<" in db" << endl;
  599.     result = NDBT_FAILED;
  600.   }
  601.   
  602.   // Verify that table is not in db     
  603.   const NdbDictionary::Table* pTab3 = 
  604.     NDBT_Table::discoverTableFromDb(pNdb, pTab->getName());
  605.   if (pTab3 != NULL){
  606.     ndbout << pTab3->getName() << " was found in DB"<< endl;
  607.     result = NDBT_FAILED;
  608.   }
  609.     
  610.   return result;
  611. }
  612. int runPkSizes(NDBT_Context* ctx, NDBT_Step* step){
  613.   int result = NDBT_OK;
  614.   char tabName[256];
  615.   int minPkSize = 1;
  616.   ndbout << "minPkSize=" <<minPkSize<<endl;
  617.   int maxPkSize = MAX_KEY_SIZE_IN_WORDS * 4;
  618.   ndbout << "maxPkSize=" <<maxPkSize<<endl;
  619.   Ndb* pNdb = GETNDB(step);
  620.   int numRecords = ctx->getNumRecords();
  621.   for (int i = minPkSize; i < maxPkSize; i++){
  622.     BaseString::snprintf(tabName, 256, "TPK_%d", i);
  623.     int records = numRecords;
  624.     int max = ~0;
  625.     // Limit num records for small PKs
  626.     if (i == 1)
  627.       max = 99;
  628.     if (i == 2)
  629.       max = 999;
  630.     if (i == 3)
  631.       max = 9999;
  632.     if (records > max)
  633.       records = max;
  634.     ndbout << "records =" << records << endl;
  635.     if (pNdb->waitUntilReady(30) != 0){
  636.       // Db is not ready, return with failure
  637.       return NDBT_FAILED;
  638.     }
  639.   
  640.     ndbout << "|- " << tabName << endl;
  641.     if (NDBT_Tables::createTable(pNdb, tabName) != 0){
  642.       ndbout << tabName << " could not be created"<< endl;
  643.       return NDBT_FAILED;
  644.     }
  645.     
  646.     // Verify that table exists in db    
  647.     const NdbDictionary::Table* pTab3 = 
  648.       NDBT_Table::discoverTableFromDb(pNdb, tabName) ;
  649.     if (pTab3 == NULL){
  650.       g_err << tabName << " was not found in DB"<< endl;
  651.       return NDBT_FAILED;
  652.     }
  653.     //    ndbout << *pTab3 << endl;
  654.     if (pTab3->equal(*NDBT_Tables::getTable(tabName)) == false){
  655.       g_err << "It was not equal" << endl;
  656.       return NDBT_FAILED;
  657.     }
  658.     do {
  659.       // Do it all
  660.       HugoTransactions hugoTrans(*pTab3);
  661.       UtilTransactions utilTrans(*pTab3);
  662.       int count;
  663.       CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  664.       CHECK(hugoTrans.pkUpdateRecords(pNdb, records) == 0);
  665.       CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  666.       CHECK(count == records);
  667.       CHECK(hugoTrans.pkDelRecords(pNdb, records/2) == 0);
  668.       CHECK(hugoTrans.scanUpdateRecords(pNdb, records) == 0);
  669.       CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  670.       CHECK(count == (records/2));
  671.       CHECK(utilTrans.clearTable(pNdb, records) == 0);
  672.       
  673. #if 0
  674.       // Fill table
  675.       CHECK(hugoTrans.fillTable(pNdb) == 0);        
  676.       CHECK(utilTrans.clearTable2(pNdb, records) == 0);
  677.       CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  678.       CHECK(count == 0);
  679. #endif
  680.     } while(false);
  681.     // Drop table
  682.     if (pNdb->getDictionary()->dropTable(pTab3->getName()) != 0){
  683.       ndbout << "Failed to drop "<<pTab3->getName()<<" in db" << endl;
  684.       return NDBT_FAILED;
  685.     }
  686.   }
  687.   return result;
  688. }
  689. int runStoreFrm(NDBT_Context* ctx, NDBT_Step* step){
  690.   Ndb* pNdb = GETNDB(step);  
  691.   const NdbDictionary::Table* pTab = ctx->getTab();
  692.   int result = NDBT_OK;
  693.   int loops = ctx->getNumLoops();
  694.   for (int l = 0; l < loops && result == NDBT_OK ; l++){
  695.     Uint32 dataLen = (Uint32)myRandom48(MAX_FRM_DATA_SIZE);
  696.     // size_t dataLen = 10;
  697.     unsigned char data[MAX_FRM_DATA_SIZE];
  698.     char start = l + 248;
  699.     for(Uint32 i = 0; i < dataLen; i++){
  700.       data[i] = start;
  701.       start++;
  702.     }
  703. #if 0
  704.     ndbout << "dataLen="<<dataLen<<endl;
  705.     for (Uint32 i = 0; i < dataLen; i++){
  706.       unsigned char c = data[i];
  707.       ndbout << hex << c << ", ";
  708.     }
  709.     ndbout << endl;
  710. #endif
  711.         
  712.     NdbDictionary::Table newTab(* pTab);
  713.     void* pData = &data;
  714.     newTab.setFrm(pData, dataLen);
  715.     
  716.     // Try to create table in db
  717.     if (newTab.createTableInDb(pNdb) != 0){
  718.       result = NDBT_FAILED;
  719.       continue;
  720.     }
  721.     
  722.     // Verify that table is in db     
  723.     const NdbDictionary::Table* pTab2 = 
  724.       NDBT_Table::discoverTableFromDb(pNdb, pTab->getName());
  725.     if (pTab2 == NULL){
  726.       g_err << pTab->getName() << " was not found in DB"<< endl;
  727.       result = NDBT_FAILED;
  728.       continue;
  729.     }
  730.     
  731.     const void* pData2 = pTab2->getFrmData();
  732.     Uint32 resultLen = pTab2->getFrmLength();
  733.     if (dataLen != resultLen){
  734.       g_err << "Length of data failure" << endl
  735.     << " expected = " << dataLen << endl
  736.     << " got = " << resultLen << endl;
  737.       result = NDBT_FAILED;      
  738.     }
  739.     
  740.     // Verfiy the frm data
  741.     if (memcmp(pData, pData2, resultLen) != 0){
  742.       g_err << "Wrong data recieved" << endl;
  743.       for (size_t i = 0; i < dataLen; i++){
  744. unsigned char c = ((unsigned char*)pData2)[i];
  745. g_err << hex << c << ", ";
  746.       }
  747.       g_err << endl;
  748.       result = NDBT_FAILED;
  749.     }
  750.     
  751.     if (pNdb->getDictionary()->dropTable(pTab2->getName()) != 0){
  752.       g_err << "It can NOT be dropped" << endl;
  753.       result = NDBT_FAILED;
  754.     } 
  755.   }
  756.   
  757.   return result;
  758. }
  759. int runStoreFrmError(NDBT_Context* ctx, NDBT_Step* step){
  760.   Ndb* pNdb = GETNDB(step);  
  761.   const NdbDictionary::Table* pTab = ctx->getTab();
  762.   int result = NDBT_OK;
  763.   int loops = ctx->getNumLoops();
  764.   for (int l = 0; l < loops && result == NDBT_OK ; l++){
  765.     const Uint32 dataLen = MAX_FRM_DATA_SIZE + 10;
  766.     unsigned char data[dataLen];
  767.     char start = l + 248;
  768.     for(Uint32 i = 0; i < dataLen; i++){
  769.       data[i] = start;
  770.       start++;
  771.     }
  772. #if 0
  773.     ndbout << "dataLen="<<dataLen<<endl;
  774.     for (Uint32 i = 0; i < dataLen; i++){
  775.       unsigned char c = data[i];
  776.       ndbout << hex << c << ", ";
  777.     }
  778.     ndbout << endl;
  779. #endif
  780.     NdbDictionary::Table newTab(* pTab);
  781.         
  782.     void* pData = &data;
  783.     newTab.setFrm(pData, dataLen);
  784.     
  785.     // Try to create table in db
  786.     if (newTab.createTableInDb(pNdb) == 0){
  787.       result = NDBT_FAILED;
  788.       continue;
  789.     }
  790.     
  791.     const NdbDictionary::Table* pTab2 = 
  792.       NDBT_Table::discoverTableFromDb(pNdb, pTab->getName());
  793.     if (pTab2 != NULL){
  794.       g_err << pTab->getName() << " was found in DB"<< endl;
  795.       result = NDBT_FAILED;
  796.       if (pNdb->getDictionary()->dropTable(pTab2->getName()) != 0){
  797. g_err << "It can NOT be dropped" << endl;
  798. result = NDBT_FAILED;
  799.       } 
  800.       
  801.       continue;
  802.     } 
  803.     
  804.   }
  805.   return result;
  806. }
  807. int verifyTablesAreEqual(const NdbDictionary::Table* pTab, const NdbDictionary::Table* pTab2){
  808.   // Verify that getPrimaryKey only returned true for primary keys
  809.   for (int i = 0; i < pTab2->getNoOfColumns(); i++){
  810.     const NdbDictionary::Column* col = pTab->getColumn(i);
  811.     const NdbDictionary::Column* col2 = pTab2->getColumn(i);
  812.     if (col->getPrimaryKey() != col2->getPrimaryKey()){
  813.       g_err << "col->getPrimaryKey() != col2->getPrimaryKey()" << endl;
  814.       return NDBT_FAILED;
  815.     }
  816.   }
  817.   
  818.   if (!pTab->equal(*pTab2)){
  819.     g_err << "equal failed" << endl;
  820.     g_info << *pTab;
  821.     g_info << *pTab2;
  822.     return NDBT_FAILED;
  823.   }
  824.   return NDBT_OK;
  825. }
  826. int runGetPrimaryKey(NDBT_Context* ctx, NDBT_Step* step){
  827.   Ndb* pNdb = GETNDB(step);
  828.   const NdbDictionary::Table* pTab = ctx->getTab();
  829.   ndbout << "|- " << pTab->getName() << endl;
  830.   g_info << *pTab;
  831.   // Try to create table in db
  832.   if (pTab->createTableInDb(pNdb) != 0){
  833.     return NDBT_FAILED;
  834.   }
  835.   const NdbDictionary::Table* pTab2 = 
  836.     NDBT_Table::discoverTableFromDb(pNdb, pTab->getName());
  837.   if (pTab2 == NULL){
  838.     ndbout << pTab->getName() << " was not found in DB"<< endl;
  839.     return NDBT_FAILED;
  840.   }
  841.   int result = NDBT_OK;
  842.   if (verifyTablesAreEqual(pTab, pTab2) != NDBT_OK)
  843.     result = NDBT_FAILED;
  844.   
  845.   
  846. #if 0
  847.   // Create an index on the table and see what 
  848.   // the function returns now
  849.   char name[200];
  850.   sprintf(name, "%s_X007", pTab->getName());
  851.   NDBT_Index* pInd = new NDBT_Index(name);
  852.   pInd->setTable(pTab->getName());
  853.   pInd->setType(NdbDictionary::Index::UniqueHashIndex);
  854.   //  pInd->setLogging(false);
  855.   for (int i = 0; i < 2; i++){
  856.     const NDBT_Attribute* pAttr = pTab->getAttribute(i);
  857.     pInd->addAttribute(*pAttr);
  858.   }
  859.   g_info << "Create index:" << endl << *pInd;
  860.   if (pInd->createIndexInDb(pNdb, false) != 0){
  861.     result = NDBT_FAILED;
  862.   }  
  863.   delete pInd;
  864.   const NdbDictionary::Table* pTab3 = 
  865.     NDBT_Table::discoverTableFromDb(pNdb, pTab->getName());
  866.   if (pTab3 == NULL){
  867.     ndbout << pTab->getName() << " was not found in DB"<< endl;
  868.     return NDBT_FAILED;
  869.   }
  870.   if (verifyTablesAreEqual(pTab, pTab3) != NDBT_OK)
  871.     result = NDBT_FAILED;
  872.   if (verifyTablesAreEqual(pTab2, pTab3) != NDBT_OK)
  873.     result = NDBT_FAILED;
  874. #endif
  875. #if 0  
  876.   if (pTab2->getDictionary()->dropTable(pNdb) != 0){
  877.     ndbout << "Failed to drop "<<pTab2->getName()<<" in db" << endl;
  878.     return NDBT_FAILED;
  879.   }
  880.   
  881.   // Verify that table is not in db     
  882.   const NdbDictionary::Table* pTab4 = 
  883.     NDBT_Table::discoverTableFromDb(pNdb, pTab->getName());
  884.   if (pTab4 != NULL){
  885.     ndbout << pTab4->getName() << " was found in DB"<< endl;
  886.     return NDBT_FAILED;
  887.   }
  888. #endif
  889.   return result;
  890. }
  891. struct ErrorCodes { int error_id; bool crash;};
  892. ErrorCodes
  893. NF_codes[] = {
  894.   {6003, true},
  895.   {6004, true},
  896.   //,6005, true,
  897.   {7173, false}
  898. };
  899. int
  900. runNF1(NDBT_Context* ctx, NDBT_Step* step){
  901.   NdbRestarter restarter;
  902.   if(restarter.getNumDbNodes() < 2)
  903.     return NDBT_OK;
  904.   myRandom48Init(NdbTick_CurrentMillisecond());
  905.   
  906.   Ndb* pNdb = GETNDB(step);
  907.   const NdbDictionary::Table* pTab = ctx->getTab();
  908.   NdbDictionary::Dictionary* dict = pNdb->getDictionary();
  909.   dict->dropTable(pTab->getName());
  910.   int result = NDBT_OK;
  911.   /**
  912.    * Need to run LCP at high rate otherwise
  913.    * packed replicas become "to many"
  914.    */
  915.   int val = DumpStateOrd::DihMinTimeBetweenLCP;
  916.   if(restarter.dumpStateAllNodes(&val, 1) != 0){
  917.     do { CHECK(0); } while(0);
  918.     g_err << "Failed to set LCP to min value" << endl;
  919.     return NDBT_FAILED;
  920.   }
  921.   
  922.   const int loops = ctx->getNumLoops();
  923.   for (int l = 0; l < loops && result == NDBT_OK ; l++){
  924.     const int sz = sizeof(NF_codes)/sizeof(NF_codes[0]);
  925.     for(int i = 0; i<sz; i++){
  926.       int rand = myRandom48(restarter.getNumDbNodes());
  927.       int nodeId = restarter.getRandomNotMasterNodeId(rand);
  928.       struct ErrorCodes err_struct = NF_codes[i];
  929.       int error = err_struct.error_id;
  930.       bool crash = err_struct.crash;
  931.       
  932.       g_info << "NF1: node = " << nodeId << " error code = " << error << endl;
  933.       
  934.       int val2[] = { DumpStateOrd::CmvmiSetRestartOnErrorInsert, 3};
  935.       
  936.       CHECK2(restarter.dumpStateOneNode(nodeId, val2, 2) == 0,
  937.      "failed to set RestartOnErrorInsert");
  938.       CHECK2(restarter.insertErrorInNode(nodeId, error) == 0,
  939.      "failed to set error insert");
  940.       
  941.       CHECK2(dict->createTable(* pTab) == 0,
  942.      "failed to create table");
  943.       if (crash) {
  944.         CHECK2(restarter.waitNodesNoStart(&nodeId, 1) == 0,
  945.     "waitNodesNoStart failed");
  946.         if(myRandom48(100) > 50){
  947.      CHECK2(restarter.startNodes(&nodeId, 1) == 0,
  948.        "failed to start node");
  949.           
  950.   CHECK2(restarter.waitClusterStarted() == 0,
  951.        "waitClusterStarted failed");
  952.      CHECK2(dict->dropTable(pTab->getName()) == 0,
  953.        "drop table failed");
  954.         } else {
  955.   CHECK2(dict->dropTable(pTab->getName()) == 0,
  956.        "drop table failed");
  957.   CHECK2(restarter.startNodes(&nodeId, 1) == 0,
  958.        "failed to start node");
  959.           
  960.   CHECK2(restarter.waitClusterStarted() == 0,
  961.        "waitClusterStarted failed");
  962.         }
  963.       
  964.         CHECK2(restarter.dumpStateOneNode(nodeId, &val, 1) == 0,
  965.      "Failed to set LCP to min value");
  966.       }
  967.     }
  968.   }
  969.  end:  
  970.   dict->dropTable(pTab->getName());
  971.   
  972.   return result;
  973. }
  974.   
  975. #define APIERROR(error) 
  976.   { g_err << "Error in " << __FILE__ << ", line:" << __LINE__ << ", code:" 
  977.               << error.code << ", msg: " << error.message << "." << endl; 
  978.   }
  979. int
  980. runCreateAutoincrementTable(NDBT_Context* ctx, NDBT_Step* step){
  981.   Uint32 startvalues[5] = {256-2, 0, 256*256-2, ~0, 256*256*256-2};
  982.   int ret = NDBT_OK;
  983.   for (int jj = 0; jj < 5 && ret == NDBT_OK; jj++) {
  984.     char tabname[] = "AUTOINCTAB";
  985.     Uint32 startvalue = startvalues[jj];
  986.     NdbDictionary::Table myTable;
  987.     NdbDictionary::Column myColumn;
  988.     Ndb* myNdb = GETNDB(step);
  989.     NdbDictionary::Dictionary* myDict = myNdb->getDictionary();
  990.     if (myDict->getTable(tabname) != NULL) {
  991.       g_err << "NDB already has example table: " << tabname << endl;
  992.       APIERROR(myNdb->getNdbError());
  993.       return NDBT_FAILED;
  994.     }
  995.     myTable.setName(tabname);
  996.     myColumn.setName("ATTR1");
  997.     myColumn.setType(NdbDictionary::Column::Unsigned);
  998.     myColumn.setLength(1);
  999.     myColumn.setPrimaryKey(true);
  1000.     myColumn.setNullable(false);
  1001.     myColumn.setAutoIncrement(true);
  1002.     if (startvalue != ~0) // check that default value starts with 1
  1003.       myColumn.setAutoIncrementInitialValue(startvalue);
  1004.     myTable.addColumn(myColumn);
  1005.     if (myDict->createTable(myTable) == -1) {
  1006.       g_err << "Failed to create table " << tabname << endl;
  1007.       APIERROR(myNdb->getNdbError());
  1008.       return NDBT_FAILED;
  1009.     }
  1010.     if (startvalue == ~0) // check that default value starts with 1
  1011.       startvalue = 1;
  1012.     for (int i = 0; i < 16; i++) {
  1013.       Uint64 value = myNdb->getAutoIncrementValue(tabname, 1);
  1014.       if (value != (startvalue+i)) {
  1015.         g_err << "value = " << value << " expected " << startvalue+i << endl;;
  1016.         APIERROR(myNdb->getNdbError());
  1017.         //      ret = NDBT_FAILED;
  1018.         //      break;
  1019.       }
  1020.     }
  1021.     if (myDict->dropTable(tabname) == -1) {
  1022.       g_err << "Failed to drop table " << tabname << endl;
  1023.       APIERROR(myNdb->getNdbError());
  1024.       ret = NDBT_FAILED;
  1025.     }
  1026.   }
  1027.   return ret;
  1028. }
  1029. int
  1030. runTableRename(NDBT_Context* ctx, NDBT_Step* step){
  1031.   int result = NDBT_OK;
  1032.   Ndb* pNdb = GETNDB(step);
  1033.   NdbDictionary::Dictionary* dict = pNdb->getDictionary();
  1034.   int records = ctx->getNumRecords();
  1035.   const int loops = ctx->getNumLoops();
  1036.   ndbout << "|- " << ctx->getTab()->getName() << endl;  
  1037.   for (int l = 0; l < loops && result == NDBT_OK ; l++){
  1038.     const NdbDictionary::Table* pTab = ctx->getTab();
  1039.     // Try to create table in db
  1040.     if (pTab->createTableInDb(pNdb) != 0){
  1041.       return NDBT_FAILED;
  1042.     }
  1043.     
  1044.     // Verify that table is in db     
  1045.     const NdbDictionary::Table* pTab2 = 
  1046.       NDBT_Table::discoverTableFromDb(pNdb, pTab->getName());
  1047.     if (pTab2 == NULL){
  1048.       ndbout << pTab->getName() << " was not found in DB"<< endl;
  1049.       return NDBT_FAILED;
  1050.     }
  1051.     ctx->setTab(pTab2);
  1052.     // Load table
  1053.     HugoTransactions hugoTrans(*ctx->getTab());
  1054.     if (hugoTrans.loadTable(pNdb, records) != 0){
  1055.       return NDBT_FAILED;
  1056.     }
  1057.     // Rename table
  1058.     BaseString pTabName(pTab->getName());
  1059.     BaseString pTabNewName(pTabName);
  1060.     pTabNewName.append("xx");
  1061.     
  1062.     const NdbDictionary::Table * oldTable = dict->getTable(pTabName.c_str());
  1063.     if (oldTable) {
  1064.       NdbDictionary::Table newTable = *oldTable;
  1065.       newTable.setName(pTabNewName.c_str());
  1066.       CHECK2(dict->alterTable(newTable) == 0,
  1067.      "TableRename failed");
  1068.     }
  1069.     else {
  1070.       result = NDBT_FAILED;
  1071.     }
  1072.     
  1073.     // Verify table contents
  1074.     NdbDictionary::Table pNewTab(pTabNewName.c_str());
  1075.     
  1076.     UtilTransactions utilTrans(pNewTab);
  1077.     if (utilTrans.clearTable(pNdb,  records) != 0){
  1078.       continue;
  1079.     }    
  1080.     // Drop table
  1081.     dict->dropTable(pNewTab.getName());
  1082.   }
  1083.  end:
  1084.   return result;
  1085. }
  1086. int
  1087. runTableRenameNF(NDBT_Context* ctx, NDBT_Step* step){
  1088.   NdbRestarter restarter;
  1089.   if(restarter.getNumDbNodes() < 2)
  1090.     return NDBT_OK;
  1091.   int result = NDBT_OK;
  1092.   Ndb* pNdb = GETNDB(step);
  1093.   NdbDictionary::Dictionary* dict = pNdb->getDictionary();
  1094.   int records = ctx->getNumRecords();
  1095.   const int loops = ctx->getNumLoops();
  1096.   ndbout << "|- " << ctx->getTab()->getName() << endl;  
  1097.   for (int l = 0; l < loops && result == NDBT_OK ; l++){
  1098.     const NdbDictionary::Table* pTab = ctx->getTab();
  1099.     // Try to create table in db
  1100.     if (pTab->createTableInDb(pNdb) != 0){
  1101.       return NDBT_FAILED;
  1102.     }
  1103.     
  1104.     // Verify that table is in db     
  1105.     const NdbDictionary::Table* pTab2 = 
  1106.       NDBT_Table::discoverTableFromDb(pNdb, pTab->getName());
  1107.     if (pTab2 == NULL){
  1108.       ndbout << pTab->getName() << " was not found in DB"<< endl;
  1109.       return NDBT_FAILED;
  1110.     }
  1111.     ctx->setTab(pTab2);
  1112.     // Load table
  1113.     HugoTransactions hugoTrans(*ctx->getTab());
  1114.     if (hugoTrans.loadTable(pNdb, records) != 0){
  1115.       return NDBT_FAILED;
  1116.     }
  1117.     BaseString pTabName(pTab->getName());
  1118.     BaseString pTabNewName(pTabName);
  1119.     pTabNewName.append("xx");
  1120.     
  1121.     const NdbDictionary::Table * oldTable = dict->getTable(pTabName.c_str());
  1122.     if (oldTable) {
  1123.       NdbDictionary::Table newTable = *oldTable;
  1124.       newTable.setName(pTabNewName.c_str());
  1125.       CHECK2(dict->alterTable(newTable) == 0,
  1126.      "TableRename failed");
  1127.     }
  1128.     else {
  1129.       result = NDBT_FAILED;
  1130.     }
  1131.     
  1132.     // Restart one node at a time
  1133.     
  1134.     /**
  1135.      * Need to run LCP at high rate otherwise
  1136.      * packed replicas become "to many"
  1137.      */
  1138.     int val = DumpStateOrd::DihMinTimeBetweenLCP;
  1139.     if(restarter.dumpStateAllNodes(&val, 1) != 0){
  1140.       do { CHECK(0); } while(0);
  1141.       g_err << "Failed to set LCP to min value" << endl;
  1142.       return NDBT_FAILED;
  1143.     }
  1144.     
  1145.     const int numNodes = restarter.getNumDbNodes();
  1146.     for(int i = 0; i<numNodes; i++){
  1147.       int nodeId = restarter.getDbNodeId(i);
  1148.       int error = NF_codes[i].error_id;
  1149.       g_info << "NF1: node = " << nodeId << " error code = " << error << endl;
  1150.       CHECK2(restarter.restartOneDbNode(nodeId) == 0,
  1151.      "failed to set restartOneDbNode");
  1152.       CHECK2(restarter.waitClusterStarted() == 0,
  1153.      "waitClusterStarted failed");
  1154.     }
  1155.     // Verify table contents
  1156.     NdbDictionary::Table pNewTab(pTabNewName.c_str());
  1157.     
  1158.     UtilTransactions utilTrans(pNewTab);
  1159.     if (utilTrans.clearTable(pNdb,  records) != 0){
  1160.       continue;
  1161.     }    
  1162.     // Drop table
  1163.     dict->dropTable(pTabNewName.c_str());
  1164.   }
  1165.  end:    
  1166.   return result;
  1167. }
  1168. int
  1169. runTableRenameSR(NDBT_Context* ctx, NDBT_Step* step){
  1170.   NdbRestarter restarter;
  1171.   if(restarter.getNumDbNodes() < 2)
  1172.     return NDBT_OK;
  1173.   int result = NDBT_OK;
  1174.   Ndb* pNdb = GETNDB(step);
  1175.   NdbDictionary::Dictionary* dict = pNdb->getDictionary();
  1176.   int records = ctx->getNumRecords();
  1177.   const int loops = ctx->getNumLoops();
  1178.   ndbout << "|- " << ctx->getTab()->getName() << endl;  
  1179.   for (int l = 0; l < loops && result == NDBT_OK ; l++){
  1180.     // Rename table
  1181.     const NdbDictionary::Table* pTab = ctx->getTab();
  1182.     // Try to create table in db
  1183.     if (pTab->createTableInDb(pNdb) != 0){
  1184.       return NDBT_FAILED;
  1185.     }
  1186.     
  1187.     // Verify that table is in db     
  1188.     const NdbDictionary::Table* pTab2 = 
  1189.       NDBT_Table::discoverTableFromDb(pNdb, pTab->getName());
  1190.     if (pTab2 == NULL){
  1191.       ndbout << pTab->getName() << " was not found in DB"<< endl;
  1192.       return NDBT_FAILED;
  1193.     }
  1194.     ctx->setTab(pTab2);
  1195.     // Load table
  1196.     HugoTransactions hugoTrans(*ctx->getTab());
  1197.     if (hugoTrans.loadTable(pNdb, records) != 0){
  1198.       return NDBT_FAILED;
  1199.     }
  1200.     BaseString pTabName(pTab->getName());
  1201.     BaseString pTabNewName(pTabName);
  1202.     pTabNewName.append("xx");
  1203.     
  1204.     const NdbDictionary::Table * oldTable = dict->getTable(pTabName.c_str());
  1205.     if (oldTable) {
  1206.       NdbDictionary::Table newTable = *oldTable;
  1207.       newTable.setName(pTabNewName.c_str());
  1208.       CHECK2(dict->alterTable(newTable) == 0,
  1209.      "TableRename failed");
  1210.     }
  1211.     else {
  1212.       result = NDBT_FAILED;
  1213.     }
  1214.     
  1215.     // Restart cluster
  1216.     
  1217.     /**
  1218.      * Need to run LCP at high rate otherwise
  1219.      * packed replicas become "to many"
  1220.      */
  1221.     int val = DumpStateOrd::DihMinTimeBetweenLCP;
  1222.     if(restarter.dumpStateAllNodes(&val, 1) != 0){
  1223.       do { CHECK(0); } while(0);
  1224.       g_err << "Failed to set LCP to min value" << endl;
  1225.       return NDBT_FAILED;
  1226.     }
  1227.     
  1228.     CHECK2(restarter.restartAll() == 0,
  1229.    "failed to set restartOneDbNode");
  1230.     
  1231.     CHECK2(restarter.waitClusterStarted() == 0,
  1232.    "waitClusterStarted failed");
  1233.     
  1234.     // Verify table contents
  1235.     NdbDictionary::Table pNewTab(pTabNewName.c_str());
  1236.     
  1237.     UtilTransactions utilTrans(pNewTab);
  1238.     if (utilTrans.clearTable(pNdb,  records) != 0){
  1239.       continue;
  1240.     }    
  1241.     // Drop table
  1242.     dict->dropTable(pTabNewName.c_str());
  1243.   }
  1244.  end:    
  1245.   return result;
  1246. }
  1247. static void
  1248. f(const NdbDictionary::Column * col){
  1249.   if(col == 0){
  1250.     abort();
  1251.   }
  1252. }
  1253. int
  1254. runTestDictionaryPerf(NDBT_Context* ctx, NDBT_Step* step){
  1255.   Vector<char*> cols;
  1256.   Vector<const NdbDictionary::Table*> tabs;
  1257.   int i;
  1258.   Ndb* pNdb = GETNDB(step);  
  1259.   const Uint32 count = NDBT_Tables::getNumTables();
  1260.   for (i=0; i < count; i++){
  1261.     const NdbDictionary::Table * tab = NDBT_Tables::getTable(i);
  1262.     pNdb->getDictionary()->createTable(* tab);
  1263.     
  1264.     const NdbDictionary::Table * tab2 = pNdb->getDictionary()->getTable(tab->getName());
  1265.     
  1266.     for(size_t j = 0; j<tab->getNoOfColumns(); j++){
  1267.       cols.push_back((char*)tab2);
  1268.       cols.push_back(strdup(tab->getColumn(j)->getName()));
  1269.     }
  1270.   }
  1271.   const Uint32 times = 10000000;
  1272.   ndbout_c("%d tables and %d columns", 
  1273.    NDBT_Tables::getNumTables(), cols.size()/2);
  1274.   char ** tcols = cols.getBase();
  1275.   srand(time(0));
  1276.   Uint32 size = cols.size() / 2;
  1277.   char ** columns = &cols[0];
  1278.   Uint64 start = NdbTick_CurrentMillisecond();
  1279.   for(i = 0; i<times; i++){
  1280.     int j = 2 * (rand() % size);
  1281.     const NdbDictionary::Table* tab = (const NdbDictionary::Table*)tcols[j];
  1282.     const char * col = tcols[j+1];
  1283.     const NdbDictionary::Column* column = tab->getColumn(col);
  1284.     f(column);
  1285.   }
  1286.   Uint64 stop = NdbTick_CurrentMillisecond();
  1287.   stop -= start;
  1288.   Uint64 per = stop;
  1289.   per *= 1000;
  1290.   per /= times;
  1291.   
  1292.   ndbout_c("%d random getColumn(name) in %Ld ms -> %d us/get",
  1293.    times, stop, per);
  1294.   return NDBT_OK;
  1295. }
  1296. int runFailAddFragment(NDBT_Context* ctx, NDBT_Step* step){
  1297.   static int acclst[] = { 3001 };
  1298.   static int tuplst[] = { 4007, 4008, 4009, 4010, 4011, 4012 };
  1299.   static int tuxlst[] = { 12001, 12002, 12003, 12004, 12005, 12006 };
  1300.   static unsigned acccnt = sizeof(acclst)/sizeof(acclst[0]);
  1301.   static unsigned tupcnt = sizeof(tuplst)/sizeof(tuplst[0]);
  1302.   static unsigned tuxcnt = sizeof(tuxlst)/sizeof(tuxlst[0]);
  1303.   NdbRestarter restarter;
  1304.   int nodeId = restarter.getMasterNodeId();
  1305.   Ndb* pNdb = GETNDB(step);  
  1306.   NdbDictionary::Dictionary* pDic = pNdb->getDictionary();
  1307.   NdbDictionary::Table tab(*ctx->getTab());
  1308.   tab.setFragmentType(NdbDictionary::Object::FragAllLarge);
  1309.   // ordered index on first few columns
  1310.   NdbDictionary::Index idx("X");
  1311.   idx.setTable(tab.getName());
  1312.   idx.setType(NdbDictionary::Index::OrderedIndex);
  1313.   idx.setLogging(false);
  1314.   for (int i_hate_broken_compilers = 0;
  1315.        i_hate_broken_compilers < 3 &&
  1316.        i_hate_broken_compilers < tab.getNoOfColumns();
  1317.        i_hate_broken_compilers++) {
  1318.     idx.addColumn(*tab.getColumn(i_hate_broken_compilers));
  1319.   }
  1320.   const int loops = ctx->getNumLoops();
  1321.   int result = NDBT_OK;
  1322.   (void)pDic->dropTable(tab.getName());
  1323.   for (int l = 0; l < loops; l++) {
  1324.     for (unsigned i0 = 0; i0 < acccnt; i0++) {
  1325.       unsigned j = (l == 0 ? i0 : myRandom48(acccnt));
  1326.       int errval = acclst[j];
  1327.       g_info << "insert error node=" << nodeId << " value=" << errval << endl;
  1328.       CHECK2(restarter.insertErrorInNode(nodeId, errval) == 0,
  1329.              "failed to set error insert");
  1330.       CHECK2(pDic->createTable(tab) != 0,
  1331.              "failed to fail after error insert " << errval);
  1332.       CHECK2(pDic->createTable(tab) == 0,
  1333.              pDic->getNdbError());
  1334.       CHECK2(pDic->dropTable(tab.getName()) == 0,
  1335.              pDic->getNdbError());
  1336.     }
  1337.     for (unsigned i1 = 0; i1 < tupcnt; i1++) {
  1338.       unsigned j = (l == 0 ? i1 : myRandom48(tupcnt));
  1339.       int errval = tuplst[j];
  1340.       g_info << "insert error node=" << nodeId << " value=" << errval << endl;
  1341.       CHECK2(restarter.insertErrorInNode(nodeId, errval) == 0,
  1342.              "failed to set error insert");
  1343.       CHECK2(pDic->createTable(tab) != 0,
  1344.              "failed to fail after error insert " << errval);
  1345.       CHECK2(pDic->createTable(tab) == 0,
  1346.              pDic->getNdbError());
  1347.       CHECK2(pDic->dropTable(tab.getName()) == 0,
  1348.              pDic->getNdbError());
  1349.     }
  1350.     for (unsigned i2 = 0; i2 < tuxcnt; i2++) {
  1351.       unsigned j = (l == 0 ? i2 : myRandom48(tuxcnt));
  1352.       int errval = tuxlst[j];
  1353.       g_info << "insert error node=" << nodeId << " value=" << errval << endl;
  1354.       CHECK2(restarter.insertErrorInNode(nodeId, errval) == 0,
  1355.              "failed to set error insert");
  1356.       CHECK2(pDic->createTable(tab) == 0,
  1357.              pDic->getNdbError());
  1358.       CHECK2(pDic->createIndex(idx) != 0,
  1359.              "failed to fail after error insert " << errval);
  1360.       CHECK2(pDic->createIndex(idx) == 0,
  1361.              pDic->getNdbError());
  1362.       CHECK2(pDic->dropTable(tab.getName()) == 0,
  1363.              pDic->getNdbError());
  1364.     }
  1365.   }
  1366. end:
  1367.   return result;
  1368. }
  1369. NDBT_TESTSUITE(testDict);
  1370. TESTCASE("CreateAndDrop", 
  1371.  "Try to create and drop the table loop number of timesn"){
  1372.   INITIALIZER(runCreateAndDrop);
  1373. }
  1374. TESTCASE("CreateAndDropWithData", 
  1375.  "Try to create and drop the table when it's filled with datan"
  1376.  "do this loop number of timesn"){
  1377.   INITIALIZER(runCreateAndDropWithData);
  1378. }
  1379. TESTCASE("CreateAndDropDuring", 
  1380.  "Try to create and drop the table when other thread is using itn"
  1381.  "do this loop number of timesn"){
  1382.   STEP(runCreateAndDropDuring);
  1383.   STEP(runUseTableUntilStopped);
  1384. }
  1385. TESTCASE("CreateInvalidTables", 
  1386.  "Try to create the invalid tables we have definedn"){ 
  1387.   INITIALIZER(runCreateInvalidTables);
  1388. }
  1389. TESTCASE("CreateTableWhenDbIsFull", 
  1390.  "Try to create a new table when db already is fulln"){ 
  1391.   INITIALIZER(runCreateTheTable);
  1392.   INITIALIZER(runFillTable);
  1393.   INITIALIZER(runCreateTableWhenDbIsFull);
  1394.   INITIALIZER(runDropTableWhenDbIsFull);
  1395.   FINALIZER(runClearTable);
  1396. }
  1397. TESTCASE("FragmentTypeSingle", 
  1398.  "Create the table with fragment type Singlen"){
  1399.   TC_PROPERTY("FragmentType", 1);
  1400.   INITIALIZER(runTestFragmentTypes);
  1401. }
  1402. TESTCASE("FragmentTypeAll", 
  1403.  "Create the table with fragment type Alln"){ 
  1404.   TC_PROPERTY("FragmentType", 2);
  1405.   INITIALIZER(runTestFragmentTypes);
  1406. }
  1407. TESTCASE("FragmentTypeAllLarge", 
  1408.  "Create the table with fragment type AllLargen"){ 
  1409.   TC_PROPERTY("FragmentType", 3);
  1410.   INITIALIZER(runTestFragmentTypes);
  1411. }
  1412. TESTCASE("TemporaryTables", 
  1413.  "Create the table as temporary and make sure it doesn'tn"
  1414.  "contain any data when system is restartedn"){ 
  1415.   INITIALIZER(runTestTemporaryTables);
  1416. }
  1417. TESTCASE("CreateMaxTables", 
  1418.  "Create tables until db says that it can't create any moren"){
  1419.   TC_PROPERTY("tables", 1000);
  1420.   INITIALIZER(runCreateMaxTables);
  1421.   FINALIZER(runDropMaxTables);
  1422. }
  1423. TESTCASE("PkSizes", 
  1424.  "Create tables with all different primary key sizes.n"
  1425.  "Test all data operations insert, update, delete etc.n"
  1426.  "Drop table."){
  1427.   INITIALIZER(runPkSizes);
  1428. }
  1429. TESTCASE("StoreFrm", 
  1430.  "Test that a frm file can be properly stored as part of then"
  1431.  "data in Dict."){
  1432.   INITIALIZER(runStoreFrm);
  1433. }
  1434. TESTCASE("GetPrimaryKey", 
  1435.  "Test the function NdbDictionary::Column::getPrimaryKeyn"
  1436.  "It should return true only if the column is part of n"
  1437.  "the primary key in the table"){
  1438.   INITIALIZER(runGetPrimaryKey);
  1439. }
  1440. TESTCASE("StoreFrmError", 
  1441.  "Test that a frm file with too long length can't be stored."){
  1442.   INITIALIZER(runStoreFrmError);
  1443. }
  1444. TESTCASE("NF1", 
  1445.  "Test that create table can handle NF (not master)"){
  1446.   INITIALIZER(runNF1);
  1447. }
  1448. TESTCASE("TableRename",
  1449.  "Test basic table rename"){
  1450.   INITIALIZER(runTableRename);
  1451. }
  1452. TESTCASE("TableRenameNF",
  1453.  "Test that table rename can handle node failure"){
  1454.   INITIALIZER(runTableRenameNF);
  1455. }
  1456. TESTCASE("TableRenameSR",
  1457.  "Test that table rename can handle system restart"){
  1458.   INITIALIZER(runTableRenameSR);
  1459. }
  1460. TESTCASE("DictionaryPerf",
  1461.  ""){
  1462.   INITIALIZER(runTestDictionaryPerf);
  1463. }
  1464. TESTCASE("FailAddFragment",
  1465.          "Fail add fragment or attribute in ACC or TUP or TUXn"){
  1466.   INITIALIZER(runFailAddFragment);
  1467. }
  1468. NDBT_TESTSUITE_END(testDict);
  1469. int main(int argc, const char** argv){
  1470.   ndb_init();
  1471.   // Tables should not be auto created
  1472.   testDict.setCreateTable(false);
  1473.   myRandom48Init(NdbTick_CurrentMillisecond());
  1474.   return testDict.execute(argc, argv);
  1475. }