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

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

MySQL数据库

开发平台：

Visual C++

index.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. /* ***************************************************
  18.        INDEX TEST 1
  19.        Test index functionality of NDB
  21.        Arguments:
  22.         -T create table
  23.         -L include a long attribute in key or index
  24.         -2 define primary key with two attributes
  25.         -c create index
  26. -p make index unique (include primary key attribute)
  27.         -r read using index
  28. -u update using index
  29. -d delete using index
  30. -n<no operations> do n operations (for -I -r -u -d -R -U -D)
  31. -o<no parallel operations> (for -I -r -u -d -R -U -D)
  32. -m<no indexes>
  34.        Returns:
  35.         0 - Test passed
  36.        -1 - Test failed
  37.         1 - Invalid arguments
  38.  * *************************************************** */
  40. #include <ndb_global.h>
  42. #include <NdbApi.hpp>
  43. #include <NdbOut.hpp>
  44. #include <NdbTick.h>
  45. #include <NdbMain.h>
  46. #include <NdbTest.hpp>
  47. #include <NDBT_Error.hpp>
  49. #ifndef MIN
  50. #define MIN(x,y) (((x)<(y))?(x):(y))
  51. #endif
  53. #define MAX_NO_PARALLEL_OPERATIONS 100
  55. bool testPassed = true;
  57. static void
  58. error_handler(const NdbError & err)
  59. {
  60.   // Test failed 
  61.   ndbout << endl << err << endl;
  62.   testPassed = false;
  63. }
  65. static void
  66. error_handler4(int line, const NdbError & err){
  67.   ndbout << endl << "Line " << line << endl;
  68.   // Test failed 
  69.   ndbout << err << endl;
  70.   testPassed = false;
  71. }
  73. static char *longName, *sixtysix, *ninetynine, *hundred;
  75. static void createTable(Ndb &myNdb, bool storeInACC, bool twoKey, bool longKey)
  76. {
  77.   NdbDictionary::Dictionary* dict = myNdb.getDictionary();
  78.   NdbDictionary::Table table("PERSON");
  79.   //NdbDictionary::Column column(); // Bug
  80.   NdbDictionary::Column column;
  81.   int res;
  83.   column.setName("NAME");
  84.   column.setType(NdbDictionary::Column::Char);
  85.   column.setLength((longKey)?
  86.    1024       // 1KB => long key
  87.    :12);
  88.   column.setPrimaryKey(true);
  89.   column.setNullable(false);
  90.   table.addColumn(column);
  92.   if (twoKey) {
  93.     column.setName("KEY2");
  94.     column.setType(NdbDictionary::Column::Unsigned);
  95.     column.setLength(1);
  96.     column.setPrimaryKey(true);
  97.     column.setNullable(false);
  98.     table.addColumn(column);
  99.   }
  101.   column.setName("PNUM1");
  102.   column.setType(NdbDictionary::Column::Unsigned);
  103.   column.setLength(1);
  104.   column.setPrimaryKey(false);
  105.   column.setNullable(false);
  106.   table.addColumn(column);
  108.   column.setName("PNUM2");
  109.   column.setType(NdbDictionary::Column::Unsigned);
  110.   column.setLength(1);
  111.   column.setPrimaryKey(false);
  112.   column.setNullable(false);
  113.   table.addColumn(column);
  115.   column.setName("PNUM3");
  116.   column.setType(NdbDictionary::Column::Unsigned);
  117.   column.setLength(1);
  118.   column.setPrimaryKey(false);
  119.   column.setNullable(false);
  120.   table.addColumn(column);
  122.   column.setName("PNUM4");
  123.   column.setType(NdbDictionary::Column::Unsigned);
  124.   column.setLength(1);
  125.   column.setPrimaryKey(false);
  126.   column.setNullable(false);
  127.   table.addColumn(column);
  129.   column.setName("AGE");
  130.   column.setType(NdbDictionary::Column::Unsigned);
  131.   column.setLength(1);
  132.   column.setPrimaryKey(false);
  133.   column.setNullable(false);
  134.   table.addColumn(column);
  136.   column.setName("STRING_AGE");
  137.   column.setType(NdbDictionary::Column::Char);
  138.   column.setLength(1);
  139.   column.setLength(256);
  140.   column.setPrimaryKey(false);
  141.   column.setNullable(false);
  142.   table.addColumn(column);
  144.   if ((res = dict->createTable(table)) == -1) {
  145.     error_handler(dict->getNdbError());
  146.   }
  147.   else
  148.       ndbout << "Created table" << ((longKey)?" with long key":"") <<endl;
  149. }
  151. static void createIndex(Ndb &myNdb, bool includePrimary, unsigned int noOfIndexes)
  152. {
  153.   Uint64 before, after;
  154.   NdbDictionary::Dictionary* dict = myNdb.getDictionary();
  155.   char indexName[] = "PNUMINDEX0000";
  156.   int res;
  158.   for(unsigned int indexNum = 0; indexNum < noOfIndexes; indexNum++) {
  159.     sprintf(indexName, "PNUMINDEX%.4u", indexNum);
  160.     NdbDictionary::Index index(indexName);
  161.     index.setTable("PERSON");
  162.     index.setType(NdbDictionary::Index::UniqueHashIndex);
  163.     if (includePrimary) {
  164.       const char* attr_arr[] = {"NAME", "PNUM1", "PNUM3"};
  165.       index.addIndexColumns(3, attr_arr);
  166.     }
  167.     else {
  168.       const char* attr_arr[] = {"PNUM1", "PNUM3"};
  169.       index.addIndexColumns(2, attr_arr);
  170.     }
  171.     before = NdbTick_CurrentMillisecond();
  172.     if ((res = dict->createIndex(index)) == -1) {
  173.       error_handler(dict->getNdbError());
  174.     }    
  175.     after = NdbTick_CurrentMillisecond();
  176.     ndbout << "Created index " << indexName << ", " << after - before << " msec" << endl;
  177.   }
  178. }
  179.   
  180. static void insertTable(Ndb &myNdb, unsigned int noOfTuples, unsigned int noOfOperations, bool oneTrans, bool twoKey, bool longKey)
  181. {
  182.   Uint64 tbefore, tafter, before, after;
  183.   NdbConnection  *myTrans;  
  184.   NdbOperation   *myOp;   
  185.   char name[] = "Kalle0000000";
  186.   
  187.   tbefore = NdbTick_CurrentMillisecond();
  188.   if (oneTrans) myTrans = myNdb.startTransaction();
  189.   for (unsigned int i = 0; i<noOfTuples; i++) {
  190.     if (!oneTrans) myTrans = myNdb.startTransaction();
  191.     for(unsigned int j = 1; 
  192. ((j<=noOfOperations)&&(i<noOfTuples)); 
  193. (++j<=noOfOperations)?i++:i) { 
  194.       if (myTrans == NULL) 
  195. error_handler4(__LINE__, myNdb.getNdbError());
  196.       
  197.       myOp = myTrans->getNdbOperation("PERSON"); 
  198.       if (myOp == NULL) 
  199. error_handler4(__LINE__, myTrans->getNdbError());
  200.       
  201.       myOp->insertTuple();
  202.       sprintf(name, "Kalle%.7i", i);
  203.       if (longKey)
  204. memcpy(longName, name, strlen(name)); 
  205.       if (myOp->equal("NAME", (longKey)?longName:name) == -1) {
  206. error_handler4(__LINE__, myTrans->getNdbError());
  207. myNdb.closeTransaction(myTrans);
  208. break;
  209.       }      
  210.       if (twoKey)
  211. if (myOp->equal("KEY2", i) == -1) {
  212.   error_handler4(__LINE__, myTrans->getNdbError());
  213.   myNdb.closeTransaction(myTrans);
  214.   break;
  215. }      
  216.       if (myOp->setValue("PNUM1", 17) == -1) {
  217. error_handler4(__LINE__, myTrans->getNdbError());
  218. myNdb.closeTransaction(myTrans);
  219. break;
  220.       }      
  221.       if (myOp->setValue("PNUM2", 18)) {
  222. error_handler4(__LINE__, myTrans->getNdbError());
  223. myNdb.closeTransaction(myTrans);
  224. break;
  225.       }      
  226.       if (myOp->setValue("PNUM3", 19)) {
  227. error_handler4(__LINE__, myTrans->getNdbError());
  228. myNdb.closeTransaction(myTrans);
  229. break;
  230.       }      
  231.       if (myOp->setValue("PNUM4", 20)) {
  232. error_handler4(__LINE__, myTrans->getNdbError());
  233. myNdb.closeTransaction(myTrans);
  234. break;
  235.       }      
  236.       if (myOp->setValue("AGE", ((i % 2) == 0)?66:99) == -1) {
  237. error_handler4(__LINE__, myTrans->getNdbError());
  238. myNdb.closeTransaction(myTrans);
  239. break;
  240.       }      
  241.       if (myOp->setValue("STRING_AGE", ((i % 2) == 0)?sixtysix:ninetynine) == -1) {
  242. error_handler4(__LINE__, myTrans->getNdbError());
  243. myNdb.closeTransaction(myTrans);
  244. break;
  245.       }      
  246.     }
  247.     if (noOfOperations == 1)
  248.       printf("Trying to insert person %sn", name);
  249.     else
  250.       printf("Trying to insert %u personsn", noOfOperations);
  251.     before = NdbTick_CurrentMillisecond();
  252.     if (myTrans->execute( (oneTrans) ? NoCommit : Commit ) == -1)
  253.       {
  254.         error_handler4(__LINE__, myTrans->getNdbError());
  255.         myNdb.closeTransaction(myTrans);
  256.         break;
  257.       }
  258.     after = NdbTick_CurrentMillisecond();
  259.     if (noOfOperations == 1)
  260.       printf("Inserted person %s, %u msecn", name, (Uint32) after - before);
  261.     else
  262.       printf("Inserted %u persons, %u msecn", noOfOperations, (Uint32) after - before);
  263.     if (!oneTrans) myNdb.closeTransaction(myTrans);
  264.   }
  265.   if (oneTrans) {
  266.     if (myTrans->execute( Commit ) == -1) {
  267.       error_handler4(__LINE__, myTrans->getNdbError());
  268.     }
  269.     myNdb.closeTransaction(myTrans);
  270.   }
  271.   tafter = NdbTick_CurrentMillisecond();
  273.   ndbout << "Inserted "<< noOfTuples << " tuples in " << ((oneTrans) ? 1 : noOfTuples) << " transaction(s), " << tafter - tbefore << " msec" << endl;        
  274. }
  275.  
  276. static void updateTable(Ndb &myNdb, unsigned int noOfTuples, unsigned int noOfOperations, bool oneTrans, bool twoKey, bool longKey)
  277. {
  278.   Uint64 tbefore, tafter, before, after;
  279.   NdbConnection  *myTrans;  
  280.   NdbOperation   *myOp;   
  281.   char name[] = "Kalle0000000";
  282.   
  283.   tbefore = NdbTick_CurrentMillisecond();
  284.   if (oneTrans) myTrans = myNdb.startTransaction();
  285.   for (unsigned int i = 0; i<noOfTuples; i++) {
  286.     if (!oneTrans) myTrans = myNdb.startTransaction();
  287.     for(unsigned int j = 1; 
  288. ((j<=noOfOperations)&&(i<noOfTuples)); 
  289. (++j<=noOfOperations)?i++:i) { 
  290.       if (myTrans == NULL) 
  291. error_handler4(__LINE__, myNdb.getNdbError());
  292.       
  293.       myOp = myTrans->getNdbOperation("PERSON"); 
  294.       if (myOp == NULL) 
  295. error_handler4(__LINE__, myTrans->getNdbError());
  296.       
  297.       myOp->updateTuple();
  298.       sprintf(name, "Kalle%.7i", i);
  299.       if (longKey)
  300. memcpy(longName, name, strlen(name)); 
  301.       if (myOp->equal("NAME", (longKey)?longName:name) == -1) {
  302. error_handler4(__LINE__, myTrans->getNdbError());
  303. myNdb.closeTransaction(myTrans);
  304. break;
  305.       }      
  306.       if (twoKey)
  307. if (myOp->equal("KEY2", i) == -1) {
  308.   error_handler4(__LINE__, myTrans->getNdbError());
  309.   myNdb.closeTransaction(myTrans);
  310.   break;
  311. }      
  312.       if (myOp->setValue("PNUM1", 77) == -1) {
  313. error_handler4(__LINE__, myTrans->getNdbError());
  314. myNdb.closeTransaction(myTrans);
  315. break;
  316.       }      
  317.       if (myOp->setValue("PNUM2", 88)) {
  318. error_handler4(__LINE__, myTrans->getNdbError());
  319. myNdb.closeTransaction(myTrans);
  320. break;
  321.       }      
  322.       if (myOp->setValue("PNUM4", 99)) {
  323. error_handler4(__LINE__, myTrans->getNdbError());
  324. myNdb.closeTransaction(myTrans);
  325. break;
  326.       }      
  327.       if (myOp->setValue("AGE", 100) == -1) {
  328. error_handler4(__LINE__, myTrans->getNdbError());
  329. myNdb.closeTransaction(myTrans);
  330. break;
  331.       }      
  332.       if (myOp->setValue("STRING_AGE", hundred) == -1) {
  333. error_handler4(__LINE__, myTrans->getNdbError());
  334. myNdb.closeTransaction(myTrans);
  335. break;
  336.       }
  337.     }
  338.     if (noOfOperations == 1)
  339.       printf("Trying to update person %sn", name);
  340.     else
  341.       printf("Trying to update %u personsn", noOfOperations);
  342.       before = NdbTick_CurrentMillisecond();
  343.       if (myTrans->execute( (oneTrans) ? NoCommit : Commit ) == -1)
  344. {
  345.   error_handler4(__LINE__, myTrans->getNdbError());
  346.   myNdb.closeTransaction(myTrans);
  347.   break;
  348. }
  349.       after = NdbTick_CurrentMillisecond();
  350.       if (noOfOperations == 1)
  351. printf("Updated person %s, %u msecn", name, (Uint32) after - before);
  352.       else
  353. printf("Update %u persons, %u msecn", noOfOperations, (Uint32) after - before);
  354.       if (!oneTrans) myNdb.closeTransaction(myTrans);
  355.   }     
  356.   if (oneTrans) {
  357.     if (myTrans->execute( Commit ) == -1) {
  358.       error_handler4(__LINE__, myTrans->getNdbError());
  359.     }
  360.     myNdb.closeTransaction(myTrans);
  361.   }
  362.   tafter = NdbTick_CurrentMillisecond();
  363.   
  364.   ndbout << "Updated "<< noOfTuples << " tuples in " << ((oneTrans) ? 1 : noOfTuples) << " transaction(s), " << tafter - tbefore << " msec" << endl;        
  365. }
  367. static void deleteTable(Ndb &myNdb, unsigned int noOfTuples, unsigned int noOfOperations, bool oneTrans, bool twoKey, bool longKey)
  368. {
  369.   Uint64 tbefore, tafter, before, after;
  370.   NdbConnection  *myTrans;  
  371.   NdbOperation   *myOp;   
  372.   char name[] = "Kalle0000000";
  373.   
  374.   tbefore = NdbTick_CurrentMillisecond();
  375.   if (oneTrans) myTrans = myNdb.startTransaction();
  376.   for (unsigned int i = 0; i<noOfTuples; i++) {
  377.     if (!oneTrans) myTrans = myNdb.startTransaction();
  378.     for(unsigned int j = 1; 
  379. ((j<=noOfOperations)&&(i<noOfTuples)); 
  380. (++j<=noOfOperations)?i++:i) { 
  381.       if (myTrans == NULL) 
  382.         error_handler4(__LINE__, myNdb.getNdbError());
  383.       
  384.       myOp = myTrans->getNdbOperation("PERSON"); 
  385.       if (myOp == NULL) 
  386.         error_handler4(__LINE__, myTrans->getNdbError());
  387.       
  388.       myOp->deleteTuple();
  389.       sprintf(name, "Kalle%.7i", i);
  390.       if (longKey)
  391.         memcpy(longName, name, strlen(name)); 
  392.       if (myOp->equal("NAME", (longKey)?longName:name) == -1) {
  393.         error_handler4(__LINE__, myTrans->getNdbError());
  394.         myNdb.closeTransaction(myTrans);
  395.         break;
  396.       }      
  397.       if (twoKey)
  398.         if (myOp->equal("KEY2", i) == -1) {
  399.           error_handler4(__LINE__, myTrans->getNdbError());
  400.           myNdb.closeTransaction(myTrans);
  401.           break;
  402.         }      
  403.     }
  404.     if (noOfOperations == 1)
  405.       printf("Trying to delete person %sn", name);
  406.     else
  407.       printf("Trying to delete %u personsn", noOfOperations);
  408.     before = NdbTick_CurrentMillisecond();
  409.     if (myTrans->execute( (oneTrans) ? NoCommit : Commit ) == -1)
  410.       {
  411.         error_handler4(__LINE__, myTrans->getNdbError());
  412.         myNdb.closeTransaction(myTrans);
  413.         break;
  414.       }
  415.     after = NdbTick_CurrentMillisecond();
  416.     if (noOfOperations == 1)
  417.       printf("Deleted person %s, %u msecn", name, (Uint32) after - before);
  418.     else
  419.       printf("Deleted %u persons, %u msecn", noOfOperations, (Uint32) after - before);
  420.     
  421.     if (!oneTrans) myNdb.closeTransaction(myTrans);
  422.   }
  423.   if (oneTrans) {
  424.     if (myTrans->execute( Commit ) == -1) {
  425.       error_handler4(__LINE__, myTrans->getNdbError());
  426.     }
  427.     myNdb.closeTransaction(myTrans);
  428.   }
  429.   tafter = NdbTick_CurrentMillisecond();
  431.   ndbout << "Deleted "<< noOfTuples << " tuples in " << ((oneTrans) ? 1 : noOfTuples) << " transaction(s), " << tafter - tbefore << " msec" << endl;        
  432. }
  434. static void readTable(Ndb &myNdb, unsigned int noOfTuples, unsigned int noOfOperations, bool oneTrans, bool twoKey, bool longKey)
  435. {
  436.   Uint64 tbefore, tafter, before, after;
  437.   NdbConnection  *myTrans;  
  438.   NdbOperation   *myOp;   
  439.   char name[] = "Kalle0000000";
  440.   NdbRecAttr* myRecAttrArr[MAX_NO_PARALLEL_OPERATIONS];
  441.   
  442.   tbefore = NdbTick_CurrentMillisecond();
  443.   if (oneTrans) myTrans = myNdb.startTransaction();
  444.   for (unsigned int i = 0; i<noOfTuples; i++) {
  445.     if (!oneTrans) myTrans = myNdb.startTransaction();
  446.     for(unsigned int j = 1; 
  447. ((j<=noOfOperations)&&(i<noOfTuples)); 
  448. (++j<=noOfOperations)?i++:i) { 
  449.       if (myTrans == NULL) 
  450.         error_handler4(__LINE__, myNdb.getNdbError());
  451.       
  452.       myOp = myTrans->getNdbOperation("PERSON"); 
  453.       if (myOp == NULL) 
  454.         error_handler4(__LINE__, myTrans->getNdbError());
  455.       
  456.       myOp->readTuple();
  457.       sprintf(name, "Kalle%.7i", i);
  458.       if (longKey)
  459.         memcpy(longName, name, strlen(name)); 
  460.       if (myOp->equal("NAME", (longKey)?longName:name) == -1) {
  461.         error_handler4(__LINE__, myTrans->getNdbError());
  462.         myNdb.closeTransaction(myTrans);
  463.         break;
  464.       }         
  465.       if (twoKey)
  466.         if (myOp->equal("KEY2", i) == -1) {
  467.           error_handler4(__LINE__, myTrans->getNdbError());
  468.           myNdb.closeTransaction(myTrans);
  469.           break;
  470.         }      
  471.       myRecAttrArr[j-1] = myOp->getValue("PNUM2", NULL);
  472.     }
  473.     if (noOfOperations == 1)
  474.       printf("Trying to read person %sn", name);
  475.     else
  476.       printf("Trying to read %u personsn", noOfOperations);
  477.     before = NdbTick_CurrentMillisecond();
  478.     if (myTrans->execute( (oneTrans) ? NoCommit : Commit ) == -1)
  479.       {
  480.         error_handler4(__LINE__, myTrans->getNdbError());
  481.         myNdb.closeTransaction(myTrans);
  482.         break;
  483.       }
  484.     after = NdbTick_CurrentMillisecond();
  485.     if (noOfOperations == 1)
  486.       printf("Read person %s, %u msecn", name, (Uint32) after - before);
  487.     else
  488.       printf("Read %u persons, %u msecn", noOfOperations, (Uint32) after - before);
  489.     for(unsigned int j = 0; j<noOfOperations; j++)
  490.       printf("PNUM2 = %un", myRecAttrArr[j]->u_32_value());
  491.     if (!oneTrans) myNdb.closeTransaction(myTrans);
  492.   }
  493.   if (oneTrans) {
  494.     if (myTrans->execute( Commit ) == -1) {
  495.       error_handler4(__LINE__, myTrans->getNdbError());
  496.     }
  497.     myNdb.closeTransaction(myTrans);
  498.   }
  499.   tafter = NdbTick_CurrentMillisecond();
  501.   ndbout << "Read "<< noOfTuples << " tuples in " << ((oneTrans) ? 1 : noOfTuples) << " transaction(s), " << tafter - tbefore << " msec" << endl;        
  502. }
  504. static void readIndex(Ndb &myNdb, unsigned int noOfTuples, unsigned int noOfOperations, bool includePrimary, bool oneTrans, bool longKey)
  505. {
  506.   Uint64 tbefore, tafter, before, after;
  507.   NdbConnection  *myTrans;  
  508.   NdbIndexOperation   *myOp; 
  509.   char indexName[] = "PNUMINDEX0000";
  510.   char name[] = "Kalle0000000";
  511.   NdbRecAttr* myRecAttrArr[MAX_NO_PARALLEL_OPERATIONS];
  512.   
  513.   tbefore = NdbTick_CurrentMillisecond();
  514.   if (oneTrans) myTrans = myNdb.startTransaction();
  515.   for (unsigned int i = 0; i<noOfTuples; i++) {
  516.     if (!oneTrans) myTrans = myNdb.startTransaction();
  517.     for(unsigned int j = 1; 
  518. ((j<=noOfOperations)&&(i<noOfTuples)); 
  519. (++j<=noOfOperations)?i++:i) { 
  520.       if (myTrans == NULL) 
  521.         error_handler4(__LINE__, myNdb.getNdbError());
  522.       
  523.       myOp = myTrans->getNdbIndexOperation(indexName, "PERSON"); 
  524.       if (myOp == NULL) 
  525.         error_handler4(__LINE__, myTrans->getNdbError());
  526.       
  527.       myOp->readTuple();
  528.       if (includePrimary) {
  529.         sprintf(name, "Kalle%.7i", i);
  530.         if (longKey)
  531.           memcpy(longName, name, strlen(name)); 
  532.         if (myOp->equal("NAME", (longKey)?longName:name) == -1) {
  533.           error_handler4(__LINE__, myTrans->getNdbError());
  534.           myNdb.closeTransaction(myTrans);
  535.           break;
  536.         }         
  537.       } 
  538.       if (myOp->equal("PNUM1", 17) == -1) {
  539.         error_handler4(__LINE__, myTrans->getNdbError());
  540.         myNdb.closeTransaction(myTrans);
  541.         break;
  542.       }          
  543.       if (myOp->equal("PNUM3", 19) == -1) {
  544.         error_handler4(__LINE__, myTrans->getNdbError());
  545.         myNdb.closeTransaction(myTrans);
  546.         break;
  547.       }          
  548.       myRecAttrArr[j-1] = myOp->getValue("PNUM2", NULL);
  549.     }
  550.     if (noOfOperations == 1)
  551.       printf("Trying to read person %sn", name);
  552.     else
  553.       printf("Trying to read %u personsn", noOfOperations);
  554.     before = NdbTick_CurrentMillisecond();
  555.     if (myTrans->execute( (oneTrans) ? NoCommit : Commit ) == -1)
  556.       {
  557.         error_handler4(__LINE__, myTrans->getNdbError());
  558.         myNdb.closeTransaction(myTrans);
  559.         break;
  560.       }
  561.     after = NdbTick_CurrentMillisecond();
  562.     if (noOfOperations == 1)
  563.       printf("Read person %s, %u msecn", name, (Uint32) after - before);
  564.     else
  565.       printf("Read %u persons, %u msecn", noOfOperations, (Uint32) after - before);
  566.     for(unsigned int j = 0; j<noOfOperations; j++)
  567.       printf("PNUM2 = %un", myRecAttrArr[j]->u_32_value());
  568.     if (!oneTrans) myNdb.closeTransaction(myTrans);
  569.   }
  570.   if (oneTrans) {
  571.     if (myTrans->execute( Commit ) == -1) {
  572.       error_handler4(__LINE__, myTrans->getNdbError());
  573.     }
  574.     myNdb.closeTransaction(myTrans);
  575.   }
  576.   tafter = NdbTick_CurrentMillisecond();
  578.   ndbout << "Read "<< noOfTuples << " tuples in " << ((oneTrans) ? 1 : noOfTuples) << " transaction(s), " << tafter - tbefore << " msec" << endl;        
  579. }
  581. static void updateIndex(Ndb &myNdb, unsigned int noOfTuples, unsigned int noOfOperations, bool includePrimary, bool oneTrans, bool longKey)
  582. {
  583.   Uint64 tbefore, tafter, before, after;
  584.   NdbConnection  *myTrans;  
  585.   NdbIndexOperation   *myOp;   
  586.   char indexName[] = "PNUMINDEX0000";
  587.   char name[] = "Kalle0000000";
  588.   
  589.   tbefore = NdbTick_CurrentMillisecond();
  590.   if (oneTrans) myTrans = myNdb.startTransaction();
  591.   for (unsigned int i = 0; i<noOfTuples; i++) {
  592.     if (!oneTrans) myTrans = myNdb.startTransaction();
  593.     for(unsigned int j = 1; 
  594. ((j<=noOfOperations)&&(i<noOfTuples)); 
  595. (++j<=noOfOperations)?i++:i) { 
  596.       if (myTrans == NULL) 
  597.         error_handler4(__LINE__, myNdb.getNdbError());
  598.       
  599.       myOp = myTrans->getNdbIndexOperation(indexName, "PERSON"); 
  600.       if (myOp == NULL) 
  601.         error_handler4(__LINE__, myTrans->getNdbError());
  602.       
  603.       myOp->updateTuple();
  604.       if (includePrimary) {
  605.         sprintf(name, "Kalle%.7i", i);
  606.         if (longKey)
  607.           memcpy(longName, name, strlen(name)); 
  608.         if (myOp->equal("NAME", (longKey)?longName:name) == -1) {
  609.           error_handler4(__LINE__, myTrans->getNdbError());
  610.           myNdb.closeTransaction(myTrans);
  611.           break;
  612.         }         
  613.       } 
  614.       if (myOp->equal("PNUM1", 17) == -1) {
  615.         error_handler4(__LINE__, myTrans->getNdbError());
  616.         myNdb.closeTransaction(myTrans);
  617.         break;
  618.       } 
  619.       if (myOp->equal("PNUM3", 19) == -1) {
  620.         error_handler4(__LINE__, myTrans->getNdbError());
  621.         myNdb.closeTransaction(myTrans);
  622.         break;
  623.       }          
  624.       // Update index itself, should be possible
  625.       if (myOp->setValue("PNUM1", 77) == -1) {
  626.         error_handler4(__LINE__, myTrans->getNdbError());
  627.         myNdb.closeTransaction(myTrans);
  628.         break;
  629.       }      
  630.       if (myOp->setValue("PNUM2", 88)) {
  631.         error_handler4(__LINE__, myTrans->getNdbError());
  632.         myNdb.closeTransaction(myTrans);
  633.         break;
  634.       }      
  635.       if (myOp->setValue("PNUM4", 99)) {
  636.         error_handler4(__LINE__, myTrans->getNdbError());
  637.         myNdb.closeTransaction(myTrans);
  638.         break;
  639.       }      
  640.       if (myOp->setValue("AGE", 100) == -1) {
  641.         error_handler4(__LINE__, myTrans->getNdbError());
  642.         myNdb.closeTransaction(myTrans);
  643.         break;
  644.       }      
  645.       if (myOp->setValue("STRING_AGE", hundred) == -1) {
  646.         error_handler4(__LINE__, myTrans->getNdbError());
  647.         myNdb.closeTransaction(myTrans);
  648.         break;
  649.       }      
  650.     }
  651.     if (noOfOperations == 1)
  652.       printf("Trying to update person %sn", name);
  653.     else
  654.       printf("Trying to update %u personsn", noOfOperations);
  655.     before = NdbTick_CurrentMillisecond();
  656.     if (myTrans->execute( (oneTrans) ? NoCommit : Commit ) == -1)
  657.       {
  658.         error_handler4(__LINE__, myTrans->getNdbError());
  659.         myNdb.closeTransaction(myTrans);
  660.         break;
  661.       }
  662.     after = NdbTick_CurrentMillisecond();
  663.     if (noOfOperations == 1)
  664.       printf("Updated person %s, %u msecn", name, (Uint32) after - before);
  665.     else
  666.       printf("Updated %u persons, %u msecn", noOfOperations, (Uint32) after - before);
  667.     if (!oneTrans) myNdb.closeTransaction(myTrans);
  668.   }
  669.   if (oneTrans) {
  670.     if (myTrans->execute( Commit ) == -1) {
  671.       error_handler4(__LINE__, myTrans->getNdbError());
  672.     }
  673.     myNdb.closeTransaction(myTrans);
  674.   }
  675.   tafter = NdbTick_CurrentMillisecond();
  676.   
  677.   ndbout << "Updated "<< noOfTuples << " tuples in " << ((oneTrans) ? 1 : noOfTuples) << " transaction(s), " << tafter - tbefore << " msec" << endl;        
  678. }
  680. static void deleteIndex(Ndb &myNdb, unsigned int noOfTuples, unsigned int noOfOperations, bool includePrimary, bool oneTrans, bool longKey)
  681. {
  682.   Uint64 tbefore, tafter, before, after;
  683.   NdbConnection  *myTrans;  
  684.   NdbIndexOperation   *myOp;   
  685.   char indexName[] = "PNUMINDEX0000";
  686.   char name[] = "Kalle0000000";
  687.   
  688.   tbefore = NdbTick_CurrentMillisecond();
  689.   if (oneTrans) myTrans = myNdb.startTransaction();
  690.   for (unsigned int i = 0; i<noOfTuples; i++) {
  691.     for(unsigned int j = 1; 
  692. ((j<=noOfOperations)&&(i<noOfTuples)); 
  693. (++j<=noOfOperations)?i++:i) { 
  694.       if (!oneTrans) myTrans = myNdb.startTransaction();
  695.       if (myTrans == NULL) 
  696.         error_handler4(__LINE__, myNdb.getNdbError());
  697.       
  698.       myOp = myTrans->getNdbIndexOperation(indexName, "PERSON"); 
  699.       if (myOp == NULL) 
  700.         error_handler4(__LINE__, myTrans->getNdbError());
  701.       
  702.       myOp->deleteTuple();
  703.       if (includePrimary) {
  704.         sprintf(name, "Kalle%.7i", i);
  705.         if (longKey)
  706.           memcpy(longName, name, strlen(name)); 
  707.         if (myOp->equal("NAME", (longKey)?longName:name) == -1) {
  708.           error_handler4(__LINE__, myTrans->getNdbError());
  709.           myNdb.closeTransaction(myTrans);
  710.           break;
  711.         }         
  712.       } 
  713.       if (myOp->equal("PNUM1", 17) == -1) {
  714.         error_handler4(__LINE__, myTrans->getNdbError());
  715.       myNdb.closeTransaction(myTrans);
  716.       break;
  717.       }          
  718.       if (myOp->equal("PNUM3", 19) == -1) {
  719.         error_handler4(__LINE__, myTrans->getNdbError());
  720.         myNdb.closeTransaction(myTrans);
  721.         break;
  722.       }       
  723.     }
  724.     if (noOfOperations == 1)
  725.       printf("Trying to delete person %sn", name);
  726.     else
  727.       printf("Trying to delete %u personsn", noOfOperations);
  728.     before = NdbTick_CurrentMillisecond();
  729.     if (myTrans->execute( (oneTrans) ? NoCommit : Commit ) == -1)
  730.       {
  731.         error_handler4(__LINE__, myTrans->getNdbError());
  732.         myNdb.closeTransaction(myTrans);
  733.         break;
  734.       }
  735.     after = NdbTick_CurrentMillisecond();
  736.     if (noOfOperations == 1)
  737.       printf("Deleted person %s, %u msecn", name, (Uint32) after - before);
  738.     else
  739.       printf("Deleted %u persons, %u msecn", noOfOperations, (Uint32) after - before);
  740.     if (!oneTrans) myNdb.closeTransaction(myTrans);
  741.   }
  742.   if (oneTrans) {
  743.     if (myTrans->execute( Commit ) == -1) {
  744.       error_handler4(__LINE__, myTrans->getNdbError());
  745.     }
  746.     myNdb.closeTransaction(myTrans);
  747.   }
  748.   tafter = NdbTick_CurrentMillisecond();
  750.   ndbout << "Deleted "<< noOfTuples << " tuples in " << ((oneTrans) ? 1 : noOfTuples) << " transaction(s), " << tafter - tbefore << " msec" << endl;        
  751. }
  753. static void dropIndex(Ndb &myNdb, unsigned int noOfIndexes)
  754. {
  755.   for(unsigned int indexNum = 0; indexNum < noOfIndexes; indexNum++) {
  756.     char indexName[255];
  757.     sprintf(indexName, "PNUMINDEX%.4u", indexNum);
  758.     const Uint64 before = NdbTick_CurrentMillisecond();
  759.     const int retVal = myNdb.getDictionary()->dropIndex(indexName, "PERSON");
  760.     const Uint64 after = NdbTick_CurrentMillisecond();
  761.     
  762.     if(retVal == 0){
  763.       ndbout << "Dropped index " << indexName << ", " 
  764.      << after - before << " msec" << endl;
  765.     } else {
  766.       ndbout << "Failed to drop index " << indexName << endl;
  767.       ndbout << myNdb.getDictionary()->getNdbError() << endl;
  768.     }
  769.   }
  770. }
  772. NDB_COMMAND(indexTest, "indexTest", "indexTest", "indexTest", 65535)
  773. {
  774.   ndb_init();
  775.   bool createTableOp, createIndexOp, dropIndexOp, insertOp, updateOp, deleteOp, readOp, readIndexOp, updateIndexOp, deleteIndexOp, twoKey, longKey;
  776.   unsigned int noOfTuples = 1;
  777.   unsigned int noOfOperations = 1;
  778.   unsigned int noOfIndexes = 1;
  779.   int i = 1;
  780.   Ndb myNdb( "TEST_DB" );
  781.   int check;
  782.   bool storeInACC = false;
  783.   bool includePrimary = false;
  784.   bool oneTransaction = false;
  786.   createTableOp = createIndexOp = dropIndexOp = insertOp = updateOp = deleteOp = readOp = readIndexOp = updateIndexOp = deleteIndexOp = twoKey = longKey = false;
  787.   // Read arguments
  788.   if (argc > 1)
  789.     while (argc > 1)
  790.       {
  791. if (strcmp(argv[i], "-T") == 0)
  792.   {
  793.     createTableOp = true;
  794.     argc -= 1;
  795.     i++;
  796.   }
  797. else if (strcmp(argv[i], "-c") == 0)
  798.   {
  799.     createIndexOp = true;
  800.     argc -= 1;
  801.     i++;
  802.   }
  803. else if (strcmp(argv[i], "-X") == 0)
  804.   {
  805.     dropIndexOp = true;
  806.     argc -= 1;
  807.     i++;
  808.   }
  809. else if (strcmp(argv[i], "-I") == 0)
  810.   {
  811.     insertOp = true;
  812.     argc -= 1;
  813.     i++;
  814.   }
  815. else if (strcmp(argv[i], "-D") == 0)
  816.   {
  817.     deleteOp = true;
  818.     argc -= 1;
  819.     i++;
  820.   }
  821. else if (strcmp(argv[i], "-U") == 0)
  822.   {
  823.     updateOp = true;
  824.     argc -= 1;
  825.     i++;
  826.   }
  827. else if (strcmp(argv[i], "-R") == 0)
  828.   {
  829.     readOp = true;
  830.     argc -= 1;
  831.     i++;
  832.   }
  833. else if (strcmp(argv[i], "-r") == 0)
  834.   {
  835.     readIndexOp = true;
  836.     argc -= 1;
  837.     i++;
  838.   }
  839. else if (strcmp(argv[i], "-u") == 0)
  840.   {
  841.     updateIndexOp = true;
  842.     argc -= 1;
  843.     i++;
  844.   }
  845. else if (strcmp(argv[i], "-d") == 0)
  846.   {
  847.     deleteIndexOp = true;
  848.     argc -= 1;
  849.     i++;
  850.   }
  851. else if (strcmp(argv[i], "-s") == 0)
  852.   {
  853.     storeInACC = true;
  854.     argc -= 1;
  855.     i++;
  856.   }
  857. else if (strcmp(argv[i], "-p") == 0)
  858.   {
  859.     includePrimary = true;
  860.     argc -= 1;
  861.     i++;
  862.   }
  863. else if (strcmp(argv[i], "-L") == 0)
  864.   {
  865.     longKey = true;
  866.     argc -= 1;
  867.     i++;
  868.   }
  869.   else if (strcmp(argv[i], "-1") == 0)
  870.   {
  871.     oneTransaction = true;
  872.     argc -= 1;
  873.     i++;
  874.   }       
  875.   else if (strcmp(argv[i], "-2") == 0)
  876.   {
  877.     twoKey = true;
  878.     argc -= 1;
  879.     i++;
  880.   }       
  881.         else if (strstr(argv[i], "-n") != 0)
  882.           {
  883.             noOfTuples = atoi(argv[i]+2);
  884.             argc -= 1;
  885.             i++;
  886.           }
  887.         else if (strstr(argv[i], "-o") != 0)
  888.           {
  889.             noOfOperations = MIN(MAX_NO_PARALLEL_OPERATIONS, atoi(argv[i]+2));
  890.             argc -= 1;
  891.             i++;
  892.           }
  893.         else if (strstr(argv[i], "-m") != 0)
  894.           {
  895.             noOfIndexes = atoi(argv[i]+2);
  896.             argc -= 1;
  897.             i++;
  898.           }
  899. else if (strstr(argv[i], "-h") != 0)
  900.           {
  901.     printf("Synopsis:n");
  902.     printf("indexn");
  903.     printf("t-T create tablen");
  904.             printf("t-L include a long attribute in key or indexn");
  905.             printf("t-2 define primary key with two attributesn");
  906.             printf("t-c create indexn");
  907.     printf("t-p make index unique (include primary key attribute)n");
  908.             printf("t-r read using indexn");
  909.     printf("t-u update using indexn");
  910.     printf("t-d delete using indexn");
  911.     printf("t-n<no operations> do n operations (for -I -r -u -d -R -U -D)n");
  912.     printf("t-o<no parallel operations> (for -I -r -u -d -R -U -D)n");
  913.     printf("t-m<no indexes>n");
  914.             argc -= 1;
  915.             i++;
  916.   }
  917. else {
  918.   char errStr[256];
  920.   printf(errStr, "Illegal argument: %s", argv[i]);
  921.   exit(-1);
  922. }
  923.       }
  924.   else
  925.     {
  926.       createTableOp = createIndexOp = dropIndexOp = insertOp = updateOp = deleteOp = true;
  927.     }
  928.   if (longKey) {
  929.     longName = (char *)  malloc(1024);
  930.     for (int i = 0; i < 1023; i++)
  931.       longName[i] = 'x'; 
  932.     longName[1023] = '';
  933.   }
  934.   sixtysix = (char *)  malloc(256);
  935.   for (int i = 0; i < 255; i++)
  936.     sixtysix[i] = ' '; 
  937.   sixtysix[255] = '';
  938.   strncpy(sixtysix, "sixtysix", strlen("sixtysix"));
  939.   ninetynine = (char *)  malloc(256);
  940.   for (int i = 0; i < 255; i++)
  941.     ninetynine[i] = ' '; 
  942.   ninetynine[255] = '';
  943.   strncpy(ninetynine, "ninetynine", strlen("ninetynine"));
  944.   hundred = (char *)  malloc(256);
  945.   for (int i = 0; i < 255; i++)
  946.     hundred[i] = ' '; 
  947.   hundred[255] = '';
  948.   strncpy(hundred, "hundred", strlen("hundred"));
  949.   myNdb.init();
  950.   // Wait for Ndb to become ready
  951.   if (myNdb.waitUntilReady(30) == 0)
  952.   {
  953.     if (createTableOp)
  954.       createTable(myNdb, storeInACC, twoKey, longKey);
  956.     if (createIndexOp)
  957.       createIndex(myNdb, includePrimary, noOfIndexes);
  959.     if (insertOp)
  960.       insertTable(myNdb, noOfTuples, noOfOperations, oneTransaction, twoKey, longKey);
  962.     if (updateOp)
  963.       updateTable(myNdb, noOfTuples, noOfOperations, oneTransaction, twoKey, longKey);
  965.     if (deleteOp)
  966.       deleteTable(myNdb, noOfTuples, noOfOperations, oneTransaction, twoKey, longKey);
  968.     if (readOp)
  969.       readTable(myNdb, noOfTuples, noOfOperations, oneTransaction, twoKey, longKey);
  971.     if (readIndexOp)
  972.       readIndex(myNdb, noOfTuples, noOfOperations, includePrimary, oneTransaction, longKey);
  974.     if (updateIndexOp)
  975.       updateIndex(myNdb, noOfTuples, noOfOperations, includePrimary, oneTransaction, longKey);
  977.     if (deleteIndexOp)
  978.       deleteIndex(myNdb, noOfTuples, noOfOperations, includePrimary, oneTransaction, longKey);
  980.     if (dropIndexOp)
  981.       dropIndex(myNdb, noOfIndexes);
  982.   }
  983.   
  984.   if (testPassed)
  985.     {
  986.       // Test passed
  987.       ndbout << "OK - Test passed" << endl;
  988.     }
  989.   else
  990.     {
  991.       // Test failed
  992.       ndbout << "FAIL - Test failed" << endl;
  993.       exit(-1);
  994.     }
  995.   return 0;
  996. }