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

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

MySQL数据库

开发平台：

Visual C++

index2.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 char* errorText)
  59. {
  60.   // Test failed 
  61.   ndbout << endl << "ErrorMessage: " << errorText << endl;
  62.   testPassed = false;
  63. }
  65. static void
  66. error_handler4(int line, int status, int classif, int errNo, const char* errorText)
  67. {
  68.   ndbout << endl << "Line " << line << endl;
  69.   // Test failed 
  70.   ndbout << "Status " << status << ", Classification " << classif<< ", Error code " << errNo << "n" << errorText << endl;
  71.   testPassed = false;
  72. }
  74. static char *longName, *sixtysix, *ninetynine, *hundred;
  76. static void createTable(Ndb &myNdb, bool storeInACC, bool twoKey, bool longKey)
  77. {
  78.   NdbDictionary::Dictionary* dict = myNdb.getDictionary();
  79.   NdbDictionary::Table table("THE_TABLE");
  80.   NdbDictionary::Column column;
  81.   int res;
  83.   column.setName("X");
  84.   column.setType(NdbDictionary::Column::Unsigned);
  85.   column.setLength(1);
  86.   column.setPrimaryKey(true);
  87.   column.setNullable(false);
  88.   table.addColumn(column);
  90.   column.setName("Y");
  91.   column.setType(NdbDictionary::Column::Unsigned);
  92.   column.setLength(1);
  93.   column.setPrimaryKey(false);
  94.   column.setNullable(false);
  95.   table.addColumn(column);
  97.   if ((res = dict->createTable(table)) == -1) {
  98.     error_handler(dict->getNdbError().message);
  99.   }
  100.   else
  101.       ndbout << "Created table" << ((longKey)?" with long key":"") <<endl;
  102. }
  104. static void createIndex(Ndb &myNdb, bool includePrimary, unsigned int noOfIndexes)
  105. {
  106.   Uint64 before, after;
  107.   NdbDictionary::Dictionary* dict = myNdb.getDictionary();
  108.   char indexName[] = "INDEX0000";
  109.   int res;
  111.   for(unsigned int indexNum = 0; indexNum < noOfIndexes; indexNum++) {
  112.     sprintf(indexName, "INDEX%.4u", indexNum);
  113.     NdbDictionary::Index index(indexName);
  114.     index.setTable("THE_TABLE");
  115.     index.setType(NdbDictionary::Index::UniqueHashIndex);
  116.     if (includePrimary) {
  117.       const char* attr_arr[] = {"X", "Y"};
  118.       index.addIndexColumns(2, attr_arr);
  119.     }
  120.     else {
  121.       const char* attr_arr[] = {"Y"};
  122.       index.addIndexColumns(2, attr_arr);
  123.     }
  124.     before = NdbTick_CurrentMillisecond();
  125.     if ((res = dict->createIndex(index)) == -1) {
  126.       error_handler(dict->getNdbError().message);
  127.     }    
  128.     after = NdbTick_CurrentMillisecond();
  129.     ndbout << "Created index " << indexName << ", " << after - before << " msec"<< endl;
  130.   }
  131. }
  132.   
  133. static void insertTable(Ndb &myNdb, unsigned int noOfTuples, unsigned int noOfOperations, bool oneTrans, bool twoKey, bool longKey)
  134. {
  135.   Uint64 tbefore, tafter, before, after;
  136.   NdbConnection  *myTrans;  
  137.   NdbOperation   *myOp;   
  138.   
  139.   tbefore = NdbTick_CurrentMillisecond();
  140.   if (oneTrans) myTrans = myNdb.startTransaction();
  141.   for (unsigned int i = 0; i<noOfTuples; i++) {
  142.     if (!oneTrans) myTrans = myNdb.startTransaction();
  143.     for(unsigned int j = 1; 
  144. ((j<=noOfOperations)&&(i<noOfTuples)); 
  145. (++j<=noOfOperations)?i++:i) { 
  146.       if (myTrans == NULL) 
  147. error_handler4(__LINE__, myNdb.getNdbError().status, myNdb.getNdbError().classification,
  148.        myNdb.getNdbError().code, myNdb.getNdbError().message);
  149.       
  150.       myOp = myTrans->getNdbOperation("THE_TABLE"); 
  151.       if (myOp == NULL) 
  152. error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  153.        myTrans->getNdbError().code, myTrans->getNdbError().message);
  154.       
  155.       myOp->insertTuple();
  156.       if (myOp->equal("X", i) == -1) {
  157. error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  158.        myTrans->getNdbError().code, myTrans->getNdbError().message);
  159. myNdb.closeTransaction(myTrans);
  160. break;
  161.       }      
  162.       if (myOp->setValue("Y", i+1) == -1) {
  163. error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  164.                        myTrans->getNdbError().code, myTrans->getNdbError().message);
  165. myNdb.closeTransaction(myTrans);
  166. break;
  167.       }      
  168.     }
  169.     before = NdbTick_CurrentMillisecond();
  170.     if (myTrans->execute( (oneTrans) ? NoCommit : Commit ) == -1)
  171.       {
  172.         error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  173.                        myTrans->getNdbError().code, myTrans->getNdbError().message);
  174.         myNdb.closeTransaction(myTrans);
  175.         break;
  176.       }
  177.     after = NdbTick_CurrentMillisecond();
  178.     if (noOfOperations == 1)
  179.       printf("Inserted 1 tuple, %u msecn", (Uint32) after - before);
  180.     else
  181.       printf("Inserted %u tuples, %u msecn", noOfOperations, (Uint32) after - before);
  183.     if (!oneTrans) myNdb.closeTransaction(myTrans);
  184.   }
  185.   if (oneTrans) {
  186.     if (myTrans->execute( Commit ) == -1) {
  187.       error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  188.                      myTrans->getNdbError().code, myTrans->getNdbError().message);
  189.     }
  190.     myNdb.closeTransaction(myTrans);
  191.   }
  192.   tafter = NdbTick_CurrentMillisecond();
  194.   ndbout << "Inserted "<< noOfTuples << " tuples in " << ((oneTrans) ? 1 : noOfTuples) << " transaction(s), " << tafter - tbefore << " msec" << endl;        
  195. }
  196.  
  197. static void updateTable(Ndb &myNdb, unsigned int noOfTuples, unsigned int noOfOperations, bool oneTrans, bool twoKey, bool longKey)
  198. {
  199.   Uint64 tbefore, tafter, before, after;
  200.   NdbConnection  *myTrans;  
  201.   NdbOperation   *myOp;   
  202.   
  203.   tbefore = NdbTick_CurrentMillisecond();
  204.   if (oneTrans) myTrans = myNdb.startTransaction();
  205.   for (unsigned int i = 0; i<noOfTuples; i++) {
  206.     if (!oneTrans) myTrans = myNdb.startTransaction();
  207.     for(unsigned int j = 1; 
  208. ((j<=noOfOperations)&&(i<noOfTuples)); 
  209. (++j<=noOfOperations)?i++:i) { 
  210.       if (myTrans == NULL) 
  211. error_handler4(__LINE__, myNdb.getNdbError().status, myNdb.getNdbError().classification,
  212.        myNdb.getNdbError().code, myNdb.getNdbError().message);
  213.       
  214.       myOp = myTrans->getNdbOperation("THE_TABLE"); 
  215.       if (myOp == NULL) 
  216. error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  217.        myTrans->getNdbError().code, myTrans->getNdbError().message);
  218.       
  219.       myOp->updateTuple();
  220.       if (myOp->equal("X", i) == -1) {
  221. error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  222.        myTrans->getNdbError().code, myTrans->getNdbError().message);
  223. myNdb.closeTransaction(myTrans);
  224. break;
  225.       }      
  226.       if (myOp->setValue("Y", i+2) == -1) {
  227. error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  228.                        myTrans->getNdbError().code, myTrans->getNdbError().message);
  229. myNdb.closeTransaction(myTrans);
  230. break;
  231.       }      
  232.     }
  233.     before = NdbTick_CurrentMillisecond();
  234.     if (myTrans->execute( (oneTrans) ? NoCommit : Commit ) == -1)
  235.       {
  236. error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  237.        myTrans->getNdbError().code, myTrans->getNdbError().message);
  238. myNdb.closeTransaction(myTrans);
  239. break;
  240.       }
  241.       after = NdbTick_CurrentMillisecond();
  242.       if (noOfOperations == 1)
  243. printf("Updated 1 tuple, %u msecn", (Uint32) after - before);
  244.       else
  245. printf("Update %u tuples, %u msecn", noOfOperations, (Uint32) after - before);
  247.       if (!oneTrans) myNdb.closeTransaction(myTrans);
  248.   }    
  249.   if (oneTrans) {
  250.     if (myTrans->execute( Commit ) == -1) {
  251.       error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  252.      myTrans->getNdbError().code, myTrans->getNdbError().message);
  253.     }
  254.     myNdb.closeTransaction(myTrans);
  255.   }
  256.   tafter = NdbTick_CurrentMillisecond();
  257.   
  258.   ndbout << "Updated "<< noOfTuples << " tuples in " << ((oneTrans) ? 1 : noOfTuples) << " transaction(s), " << tafter - tbefore << " msec" << endl;        
  259. }
  261. static void deleteTable(Ndb &myNdb, unsigned int noOfTuples, unsigned int noOfOperations, bool oneTrans, bool twoKey, bool longKey)
  262. {
  263.   Uint64 tbefore, tafter, before, after;
  264.   NdbConnection  *myTrans;  
  265.   NdbOperation   *myOp;   
  266.   
  267.   tbefore = NdbTick_CurrentMillisecond();
  268.   if (oneTrans) myTrans = myNdb.startTransaction();
  269.   for (unsigned int i = 0; i<noOfTuples; i++) {
  270.     if (!oneTrans) myTrans = myNdb.startTransaction();
  271.     for(unsigned int j = 1; 
  272. ((j<=noOfOperations)&&(i<noOfTuples)); 
  273. (++j<=noOfOperations)?i++:i) { 
  274.       if (myTrans == NULL) 
  275.         error_handler4(__LINE__, myNdb.getNdbError().status, myNdb.getNdbError().classification,
  276.                        myNdb.getNdbError().code, myNdb.getNdbError().message);
  277.       
  278.       myOp = myTrans->getNdbOperation("THE_TABLE"); 
  279.       if (myOp == NULL) 
  280.         error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  281.                        myTrans->getNdbError().code, myTrans->getNdbError().message);
  282.       
  283.       myOp->deleteTuple();
  284.       if (myOp->equal("X", i) == -1) {
  285.         error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  286.                        myTrans->getNdbError().code, myTrans->getNdbError().message);
  287.         myNdb.closeTransaction(myTrans);
  288.         break;
  289.       }      
  290.     before = NdbTick_CurrentMillisecond();
  291.     if (myTrans->execute( (oneTrans) ? NoCommit : Commit ) == -1)
  292.       {
  293.         error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  294.                        myTrans->getNdbError().code, myTrans->getNdbError().message);
  295.         myNdb.closeTransaction(myTrans);
  296.         break;
  297.       }
  298.     }
  299.     after = NdbTick_CurrentMillisecond();
  300.     if (noOfOperations == 1)
  301.       printf("Deleted 1 tuple, %u msecn", (Uint32) after - before);
  302.     else
  303.       printf("Deleted %u tuples, %u msecn", noOfOperations, (Uint32) after - before);
  304.     
  305.     if (!oneTrans) myNdb.closeTransaction(myTrans);
  306.   }
  307.   if (oneTrans) {
  308.     if (myTrans->execute( Commit ) == -1) {
  309.       error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  310.                      myTrans->getNdbError().code, myTrans->getNdbError().message);
  311.     }
  312.     myNdb.closeTransaction(myTrans);
  313.   }
  314.   tafter = NdbTick_CurrentMillisecond();
  316.   ndbout << "Deleted "<< noOfTuples << " tuples in " << ((oneTrans) ? 1 : noOfTuples) << " transaction(s), " << tafter - tbefore << " msec" << endl;        
  317. }
  319. static void readTable(Ndb &myNdb, unsigned int noOfTuples, unsigned int noOfOperations, bool oneTrans, bool twoKey, bool longKey)
  320. {
  321.   Uint64 tbefore, tafter, before, after;
  322.   NdbConnection  *myTrans;  
  323.   NdbOperation   *myOp;   
  324.   NdbRecAttr* myRecAttrArr[MAX_NO_PARALLEL_OPERATIONS];
  325.   
  326.   tbefore = NdbTick_CurrentMillisecond();
  327.   if (oneTrans) myTrans = myNdb.startTransaction();
  328.   for (unsigned int i = 0; i<noOfTuples; i++) {
  329.     if (!oneTrans) myTrans = myNdb.startTransaction();
  330.     for(unsigned int j = 1; 
  331. ((j<=noOfOperations)&&(i<noOfTuples)); 
  332. (++j<=noOfOperations)?i++:i) { 
  333.       if (myTrans == NULL) 
  334.         error_handler4(__LINE__, myNdb.getNdbError().status, myNdb.getNdbError().classification,
  335.                        myNdb.getNdbError().code, myNdb.getNdbError().message);
  336.       
  337.       myOp = myTrans->getNdbOperation("THE_TABLE"); 
  338.       if (myOp == NULL) 
  339.         error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  340.                        myTrans->getNdbError().code, myTrans->getNdbError().message);
  341.       
  342.       myOp->readTuple();
  343.       if (myOp->equal("X", i) == -1) {
  344.         error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  345.                        myTrans->getNdbError().code, myTrans->getNdbError().message);
  346.         myNdb.closeTransaction(myTrans);
  347.         break;
  348.       }         
  349.       myRecAttrArr[j-1] = myOp->getValue("Y", NULL);
  350.     }
  351.     before = NdbTick_CurrentMillisecond();
  352.     if (myTrans->execute( (oneTrans) ? NoCommit : Commit ) == -1)
  353.       {
  354.         error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  355.                        myTrans->getNdbError().code, myTrans->getNdbError().message);
  356.         myNdb.closeTransaction(myTrans);
  357.         break;
  358.       }
  359.     after = NdbTick_CurrentMillisecond();
  360.     if (noOfOperations == 1)
  361.       printf("Read 1 tuple, %u msecn", (Uint32) after - before);
  362.     else
  363.       printf("Read %u tuples, %u msecn", noOfOperations, (Uint32) after - before);
  364.     for(unsigned int j = 0; j<noOfOperations; j++)
  365.       printf("Y = %un", myRecAttrArr[j]->u_32_value());
  366.     if (!oneTrans) myNdb.closeTransaction(myTrans);
  367.   }
  368.   if (oneTrans) {
  369.     if (myTrans->execute( Commit ) == -1) {
  370.       error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  371.                      myTrans->getNdbError().code, myTrans->getNdbError().message);
  372.     }
  373.     myNdb.closeTransaction(myTrans);
  374.   }
  375.   tafter = NdbTick_CurrentMillisecond();
  377.   ndbout << "Read "<< noOfTuples << " tuples in " << ((oneTrans) ? 1 : noOfTuples) << " transaction(s), " << tafter - tbefore << " msec" << endl;        
  378. }
  380. static void readIndex(Ndb &myNdb, unsigned int noOfTuples, unsigned int noOfOperations, bool includePrimary, bool oneTrans, bool longKey)
  381. {
  382.   Uint64 tbefore, tafter, before, after;
  383.   NdbConnection  *myTrans;  
  384.   NdbIndexOperation   *myOp; 
  385.   char indexName[] = "INDEX0000";
  386.   NdbRecAttr* myRecAttrArr[MAX_NO_PARALLEL_OPERATIONS];
  387.   
  388.   tbefore = NdbTick_CurrentMillisecond();
  389.   if (oneTrans) myTrans = myNdb.startTransaction();
  390.   for (unsigned int i = 0; i<noOfTuples; i++) {
  391.     if (!oneTrans) myTrans = myNdb.startTransaction();
  392.     for(unsigned int j = 1; 
  393. ((j<=noOfOperations)&&(i<noOfTuples)); 
  394. (++j<=noOfOperations)?i++:i) { 
  395.       if (myTrans == NULL) 
  396.         error_handler4(__LINE__, myNdb.getNdbError().status, myNdb.getNdbError().classification,
  397.                        myNdb.getNdbError().code, myNdb.getNdbError().message);
  398.       
  399.       myOp = myTrans->getNdbIndexOperation(indexName, "THE_TABLE"); 
  400.       if (myOp == NULL) 
  401.         error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  402.                        myTrans->getNdbError().code, myTrans->getNdbError().message);
  403.       
  404.       myOp->readTuple();
  405.       if (includePrimary) {
  406.         if (myOp->equal("X", i) == -1) {
  407.           error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  408.                          myTrans->getNdbError().code, myTrans->getNdbError().message);
  409.           myNdb.closeTransaction(myTrans);
  410.           break;
  411.         }         
  412.       } 
  413.       if (myOp->equal("Y", i+1) == -1) {
  414.         error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  415.                        myTrans->getNdbError().code, myTrans->getNdbError().message);
  416.         myNdb.closeTransaction(myTrans);
  417.         break;
  418.       }          
  419.       myRecAttrArr[j-1] = myOp->getValue("Y", NULL);
  420.     }
  421.     before = NdbTick_CurrentMillisecond();
  422.     if (myTrans->execute( (oneTrans) ? NoCommit : Commit ) == -1)
  423.       {
  424.         error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  425.                        myTrans->getNdbError().code, myTrans->getNdbError().message);
  426.         myNdb.closeTransaction(myTrans);
  427.         break;
  428.       }
  429.     after = NdbTick_CurrentMillisecond();
  430.     if (noOfOperations == 1)
  431.       printf("Read 1 tuple, %u msecn", (Uint32) after - before);
  432.     else
  433.       printf("Read %u tuples, %u msecn", noOfOperations, (Uint32) after - before);
  434.     for(unsigned int j = 0; j<noOfOperations; j++)
  435.       printf("Y = %un", myRecAttrArr[j]->u_32_value());
  436.     if (!oneTrans) myNdb.closeTransaction(myTrans);
  437.   }
  438.   if (oneTrans) {
  439.     if (myTrans->execute( Commit ) == -1) {
  440.       error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  441.                      myTrans->getNdbError().code, myTrans->getNdbError().message);
  442.     }
  443.     myNdb.closeTransaction(myTrans);
  444.   }
  445.   tafter = NdbTick_CurrentMillisecond();
  447.   ndbout << "Read "<< noOfTuples << " tuples in " << ((oneTrans) ? 1 : noOfTuples) << " transaction(s), " << tafter - tbefore << " msec" << endl;        
  448. }
  450. static void updateIndex(Ndb &myNdb, unsigned int noOfTuples, unsigned int noOfOperations, bool includePrimary, bool oneTrans, bool longKey)
  451. {
  452.   Uint64 tbefore, tafter, before, after;
  453.   NdbConnection  *myTrans;  
  454.   NdbIndexOperation   *myOp;   
  455.   char indexName[] = "INDEX0000";
  456.   
  457.   tbefore = NdbTick_CurrentMillisecond();
  458.   if (oneTrans) myTrans = myNdb.startTransaction();
  459.   for (unsigned int i = 0; i<noOfTuples; i++) {
  460.     if (!oneTrans) myTrans = myNdb.startTransaction();
  461.     for(unsigned int j = 1; 
  462. ((j<=noOfOperations)&&(i<noOfTuples)); 
  463. (++j<=noOfOperations)?i++:i) { 
  464.       if (myTrans == NULL) 
  465.         error_handler4(__LINE__, myNdb.getNdbError().status, myNdb.getNdbError().classification,
  466.                        myNdb.getNdbError().code, myNdb.getNdbError().message);
  467.       
  468.       myOp = myTrans->getNdbIndexOperation(indexName, "THE_TABLE"); 
  469.       if (myOp == NULL) 
  470.         error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  471.                        myTrans->getNdbError().code, myTrans->getNdbError().message);
  472.       
  473.       myOp->updateTuple();
  474.       if (includePrimary) {
  475.         if (myOp->equal("X", i) == -1) {
  476.           error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  477.                          myTrans->getNdbError().code, myTrans->getNdbError().message);
  478.           myNdb.closeTransaction(myTrans);
  479.           break;
  480.         }         
  481.       } 
  482.       if (myOp->equal("Y", i+1) == -1) {
  483.         error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  484.                        myTrans->getNdbError().code, myTrans->getNdbError().message);
  485.         myNdb.closeTransaction(myTrans);
  486.         break;
  487.       } 
  488.       // Update index itself, should be possible
  489.       if (myOp->setValue("Y", i+2) == -1) {
  490.         error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  491.                        myTrans->getNdbError().code, myTrans->getNdbError().message);
  492.         myNdb.closeTransaction(myTrans);
  493.         break;
  494.       }      
  495.     }
  496.     before = NdbTick_CurrentMillisecond();
  497.     if (myTrans->execute( (oneTrans) ? NoCommit : Commit ) == -1)
  498.       {
  499.         error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  500.                        myTrans->getNdbError().code, myTrans->getNdbError().message);
  501.         myNdb.closeTransaction(myTrans);
  502.         break;
  503.       }
  505.     after = NdbTick_CurrentMillisecond();
  506.     if (noOfOperations == 1)
  507.       printf("Updated 1 tuple, %u msecn", (Uint32) after - before);
  508.     else
  509.       printf("Updated %u tuples, %u msecn", noOfOperations, (Uint32) after - before);
  510.     if (!oneTrans) myNdb.closeTransaction(myTrans);
  511.   }
  512.   if (oneTrans) {
  513.     if (myTrans->execute( Commit ) == -1) {
  514.       error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  515.                      myTrans->getNdbError().code, myTrans->getNdbError().message);
  516.     }
  517.     myNdb.closeTransaction(myTrans);
  518.   }
  519.   tafter = NdbTick_CurrentMillisecond();
  520.   
  521.   ndbout << "Updated "<< noOfTuples << " tuples in " << ((oneTrans) ? 1 : noOfTuples) << " transaction(s), " << tafter - tbefore << " msec" << endl;        
  522. }
  524. static void deleteIndex(Ndb &myNdb, unsigned int noOfTuples, unsigned int noOfOperations, bool includePrimary, bool oneTrans, bool longKey)
  525. {
  526.   Uint64 tbefore, tafter, before, after;
  527.   NdbConnection  *myTrans;  
  528.   NdbIndexOperation   *myOp;   
  529.   char indexName[] = "INDEX0000";
  530.   
  531.   tbefore = NdbTick_CurrentMillisecond();
  532.   if (oneTrans) myTrans = myNdb.startTransaction();
  533.   for (unsigned int i = 0; i<noOfTuples; i++) {
  534.     for(unsigned int j = 1; 
  535. ((j<=noOfOperations)&&(i<noOfTuples)); 
  536. (++j<=noOfOperations)?i++:i) { 
  537.       if (!oneTrans) myTrans = myNdb.startTransaction();
  538.       if (myTrans == NULL) 
  539.         error_handler4(__LINE__, myNdb.getNdbError().status, myNdb.getNdbError().classification,
  540.                        myNdb.getNdbError().code, myNdb.getNdbError().message);
  541.       
  542.       myOp = myTrans->getNdbIndexOperation(indexName, "THE_TABLE"); 
  543.       if (myOp == NULL) 
  544.         error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  545.                      myTrans->getNdbError().code, myTrans->getNdbError().message);
  546.       
  547.       myOp->deleteTuple();
  548.       if (includePrimary) {
  549.         if (myOp->equal("X", i) == -1) {
  550.           error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  551.                        myTrans->getNdbError().code, myTrans->getNdbError().message);
  552.           myNdb.closeTransaction(myTrans);
  553.           break;
  554.         }         
  555.       } 
  556.       if (myOp->equal("Y", i+1) == -1) {
  557.         error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  558.                        myTrans->getNdbError().code, myTrans->getNdbError().message);
  559.       myNdb.closeTransaction(myTrans);
  560.       break;
  561.       }          
  562.     }
  563.     before = NdbTick_CurrentMillisecond();
  564.     if (myTrans->execute( (oneTrans) ? NoCommit : Commit ) == -1)
  565.       {
  566.         error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  567.                        myTrans->getNdbError().code, myTrans->getNdbError().message);
  568.         myNdb.closeTransaction(myTrans);
  569.         break;
  570.       }
  571.     after = NdbTick_CurrentMillisecond();
  572.     if (noOfOperations == 1)
  573.       printf("Deleted 1 tuple, %u msecn", (Uint32) after - before);
  574.     else
  575.       printf("Deleted %u tuples, %u msecn", noOfOperations, (Uint32) after - before);
  576.     if (!oneTrans) myNdb.closeTransaction(myTrans);
  577.   }
  578.   if (oneTrans) {
  579.     if (myTrans->execute( Commit ) == -1) {
  580.       error_handler4(__LINE__, myTrans->getNdbError().status, myTrans->getNdbError().classification, 
  581.                      myTrans->getNdbError().code, myTrans->getNdbError().message);
  582.     }
  583.     myNdb.closeTransaction(myTrans);
  584.   }
  585.   tafter = NdbTick_CurrentMillisecond();
  587.   ndbout << "Deleted "<< noOfTuples << " tuples in " << ((oneTrans) ? 1 : noOfTuples) << " transaction(s), " << tafter - tbefore << " msec" << endl;        
  588. }
  590. static void dropIndex(Ndb &myNdb, unsigned int noOfIndexes)
  591. {
  592.   for(unsigned int indexNum = 0; indexNum < noOfIndexes; indexNum++) {
  593.     char indexName[255];
  594.     sprintf(indexName, "INDEX%.4u", indexNum);
  595.     const Uint64 before = NdbTick_CurrentMillisecond();
  596.     const int retVal = myNdb.getDictionary()->dropIndex(indexName,"THE_TABLE");
  597.     const Uint64 after = NdbTick_CurrentMillisecond();
  598.     
  599.     if(retVal == 0){
  600.       ndbout << "Dropped index " << indexName << ", " 
  601.      << after - before << " msec" << endl;
  602.     } else {
  603.       ndbout << "Failed to drop index " << indexName << endl;
  604.       ndbout << myNdb.getDictionary()->getNdbError() << endl;
  605.     }
  606.   }
  607. }
  609. NDB_COMMAND(indexTest, "indexTest", "indexTest", "indexTest", 65535)
  610. {
  611.   ndb_init();
  612.   bool createTableOp, createIndexOp, dropIndexOp, insertOp, updateOp, deleteOp, readOp, readIndexOp, updateIndexOp, deleteIndexOp, twoKey, longKey;
  613.   unsigned int noOfTuples = 1;
  614.   unsigned int noOfOperations = 1;
  615.   unsigned int noOfIndexes = 1;
  616.   int i = 1;
  617.   Ndb myNdb( "TEST_DB" );
  618.   int check;
  619.   bool storeInACC = false;
  620.   bool includePrimary = false;
  621.   bool oneTransaction = false;
  623.   createTableOp = createIndexOp = dropIndexOp = insertOp = updateOp = deleteOp = readOp = readIndexOp = updateIndexOp = deleteIndexOp = twoKey = longKey = false;
  624.   // Read arguments
  625.   if (argc > 1)
  626.     while (argc > 1)
  627.       {
  628. if (strcmp(argv[i], "-T") == 0)
  629.   {
  630.     createTableOp = true;
  631.     argc -= 1;
  632.     i++;
  633.   }
  634. else if (strcmp(argv[i], "-c") == 0)
  635.   {
  636.     createIndexOp = true;
  637.     argc -= 1;
  638.     i++;
  639.   }
  640. else if (strcmp(argv[i], "-X") == 0)
  641.   {
  642.     dropIndexOp = true;
  643.     argc -= 1;
  644.     i++;
  645.   }
  646. else if (strcmp(argv[i], "-I") == 0)
  647.   {
  648.     insertOp = true;
  649.     argc -= 1;
  650.     i++;
  651.   }
  652. else if (strcmp(argv[i], "-D") == 0)
  653.   {
  654.     deleteOp = true;
  655.     argc -= 1;
  656.     i++;
  657.   }
  658. else if (strcmp(argv[i], "-U") == 0)
  659.   {
  660.     updateOp = true;
  661.     argc -= 1;
  662.     i++;
  663.   }
  664. else if (strcmp(argv[i], "-R") == 0)
  665.   {
  666.     readOp = true;
  667.     argc -= 1;
  668.     i++;
  669.   }
  670. else if (strcmp(argv[i], "-r") == 0)
  671.   {
  672.     readIndexOp = true;
  673.     argc -= 1;
  674.     i++;
  675.   }
  676. else if (strcmp(argv[i], "-u") == 0)
  677.   {
  678.     updateIndexOp = true;
  679.     argc -= 1;
  680.     i++;
  681.   }
  682. else if (strcmp(argv[i], "-d") == 0)
  683.   {
  684.     deleteIndexOp = true;
  685.     argc -= 1;
  686.     i++;
  687.   }
  688. else if (strcmp(argv[i], "-s") == 0)
  689.   {
  690.     storeInACC = true;
  691.     argc -= 1;
  692.     i++;
  693.   }
  694. else if (strcmp(argv[i], "-p") == 0)
  695.   {
  696.     includePrimary = true;
  697.     argc -= 1;
  698.     i++;
  699.   }
  700. else if (strcmp(argv[i], "-L") == 0)
  701.   {
  702.     longKey = true;
  703.     argc -= 1;
  704.     i++;
  705.   }
  706.   else if (strcmp(argv[i], "-1") == 0)
  707.   {
  708.     oneTransaction = true;
  709.     argc -= 1;
  710.     i++;
  711.   }       
  712.   else if (strcmp(argv[i], "-2") == 0)
  713.   {
  714.     twoKey = true;
  715.     argc -= 1;
  716.     i++;
  717.   }       
  718.         else if (strstr(argv[i], "-n") != 0)
  719.           {
  720.             noOfTuples = atoi(argv[i]+2);
  721.             argc -= 1;
  722.             i++;
  723.           }
  724.         else if (strstr(argv[i], "-o") != 0)
  725.           {
  726.             noOfOperations = MIN(MAX_NO_PARALLEL_OPERATIONS, atoi(argv[i]+2));
  727.             argc -= 1;
  728.             i++;
  729.           }
  730.         else if (strstr(argv[i], "-m") != 0)
  731.           {
  732.             noOfIndexes = atoi(argv[i]+2);
  733.             argc -= 1;
  734.             i++;
  735.           }
  736. else if (strstr(argv[i], "-h") != 0)
  737.           {
  738.     printf("Synopsis: 
  739. index
  740. -T create table
  741.          -L include a long attribute in key or index
  742.          -2 define primary key with two attributes
  743.          -c create index
  744. -p make index unique (include primary key attribute)
  745.          -r read using index
  746. -u update using index
  747. -d delete using index
  748. -n<no operations> do n operations (for -I -r -u -d -R -U -D)
  749. -o<no parallel operations> (for -I -r -u -d -R -U -D)
  750. -m<no indexes>n");
  751.             argc -= 1;
  752.             i++;
  753.   }
  754. else {
  755.   char errStr[256];
  757.   sprintf(errStr, "Illegal argument: %s", argv[i]);
  758.   error_handler(errStr);
  759.   exit(-1);
  760. }
  761.       }
  762.   else
  763.     {
  764.       createTableOp = createIndexOp = dropIndexOp = insertOp = updateOp = deleteOp = true;
  765.     }
  766.   if (longKey) {
  767.     longName = (char *)  malloc(1024);
  768.     for (int i = 0; i < 1023; i++)
  769.       longName[i] = 'x'; 
  770.     longName[1023] = '';
  771.   }
  772.   sixtysix = (char *)  malloc(256);
  773.   for (int i = 0; i < 255; i++)
  774.     sixtysix[i] = ' '; 
  775.   sixtysix[255] = '';
  776.   strncpy(sixtysix, "sixtysix", strlen("sixtysix"));
  777.   ninetynine = (char *)  malloc(256);
  778.   for (int i = 0; i < 255; i++)
  779.     ninetynine[i] = ' '; 
  780.   ninetynine[255] = '';
  781.   strncpy(ninetynine, "ninetynine", strlen("ninetynine"));
  782.   hundred = (char *)  malloc(256);
  783.   for (int i = 0; i < 255; i++)
  784.     hundred[i] = ' '; 
  785.   hundred[255] = '';
  786.   strncpy(hundred, "hundred", strlen("hundred"));
  787.   myNdb.init();
  788.   // Wait for Ndb to become ready
  789.   if (myNdb.waitUntilReady(30) == 0)
  790.   {
  791.     if (createTableOp)
  792.       createTable(myNdb, storeInACC, twoKey, longKey);
  794.     if (createIndexOp)
  795.       createIndex(myNdb, includePrimary, noOfIndexes);
  797.     if (insertOp)
  798.       insertTable(myNdb, noOfTuples, noOfOperations, oneTransaction, twoKey, longKey);
  800.     if (updateOp)
  801.       updateTable(myNdb, noOfTuples, noOfOperations, oneTransaction, twoKey, longKey);
  803.     if (deleteOp)
  804.       deleteTable(myNdb, noOfTuples, noOfOperations, oneTransaction, twoKey, longKey);
  806.     if (readOp)
  807.       readTable(myNdb, noOfTuples, noOfOperations, oneTransaction, twoKey, longKey);
  809.     if (readIndexOp)
  810.       readIndex(myNdb, noOfTuples, noOfOperations, includePrimary, oneTransaction, longKey);
  812.     if (updateIndexOp)
  813.       updateIndex(myNdb, noOfTuples, noOfOperations, includePrimary, oneTransaction, longKey);
  815.     if (deleteIndexOp)
  816.       deleteIndex(myNdb, noOfTuples, noOfOperations, includePrimary, oneTransaction, longKey);
  818.     if (dropIndexOp)
  819.       dropIndex(myNdb, noOfIndexes);
  820.   }
  821.   
  822.   if (testPassed)
  823.     {
  824.       // Test passed
  825.       ndbout << "OK - Test passed" << endl;
  826.     }
  827.   else
  828.     {
  829.       // Test failed
  830.       ndbout << "FAIL - Test failed" << endl;
  831.       exit(-1);
  832.     }
  833.   return NULL;
  834. }