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

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

MySQL数据库

开发平台：

Visual C++

interpreterInTup.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.        TEST OF INTERPRETER IN TUP
  19.        Verify that the interpreter in TUP is able to
  20.        handle and execute all the commands that the
  21.        NdbApi can isssue
  23.        Arguments:
  25.        operationType     1 openScanRead,
  26.                          2 openScanExclusive,
  27.                          3 interpretedUpdateTuple,
  28.                          4 interpretedDirtyUpdate,
  29.                          5 interpretedDeleteTuple
  30.                          6 deleteTuple
  31.                          7 insertTuple
  32.                          8 updateTuple
  33.                          9 writeTuple
  34.                          10 readTuple
  35.                          11 readTupleExclusive
  36.                          12 simpleRead
  37.                          13 dirtyRead
  38.                          14 dirtyUpdate
  39.                          15 dirtyWrite
  41.        tupTest           1 exitMethods
  42.                          2 incValue
  43.                          3 subValue
  44.                          4 readAttr
  45.                          5 writeAttr
  46.                          6 loadConst
  47.                          7 branch
  48.                          8 branchIfNull
  49.                          9 addReg
  50.                          10 subReg
  51.                          11 subroutineWithBranchLabel
  53.         scanTest         Number of the test within each tupTest
  55. * *************************************************** */
  57. #include <NdbOut.hpp>
  58. #include <NdbThread.h>
  59. #include <NdbMutex.h>
  60. #include <NdbApi.hpp>
  61. #include <NdbSchemaCon.hpp>
  62. #include <NDBT.hpp>
  64. #define MAXATTR 3
  65. #define MAXTABLES 12
  66. #define MAXSTRLEN 8
  67. #define NUMBEROFRECORDS 1000
  69. typedef enum {
  70.     FAIL = 0,
  71.     NO_FAIL,
  72. UNDEF
  73. } TTYPE;
  75. inline void  setAttrNames() ;
  76. inline void  setTableNames() ;
  77. void  error_handler(const NdbError & err, TTYPE);
  78. void  create_table(Ndb*);
  79. void  write_rows(Ndb*);
  80. void  update_rows(Ndb*, int, int);
  81. void  delete_rows(Ndb*, int, int);
  82. void  verify_deleted(Ndb*);
  83. void  read_and_verify_rows(Ndb*, bool pre);
  84. void  scan_rows(Ndb*, int, int, int);
  85. TTYPE t_exitMethods(int, NdbOperation*, int);
  86. TTYPE t_incValue(int, NdbOperation*);
  87. TTYPE t_subValue(int, NdbOperation*);
  88. TTYPE t_readAttr(int, NdbOperation*);
  89. TTYPE t_writeAttr(int, NdbOperation*);
  90. TTYPE t_loadConst(int, NdbOperation*, int);
  91. TTYPE t_branch(int, NdbOperation*);
  92. TTYPE t_branchIfNull(int, NdbOperation*);
  93. TTYPE t_addReg(int, NdbOperation*);
  94. TTYPE t_subReg(int, NdbOperation*);
  95. TTYPE t_subroutineWithBranchLabel(int, NdbOperation*);
  97. char        tableName[MAXSTRLEN+1];
  98. char        attrName[MAXATTR][MAXSTRLEN+1];
  99. int         attrValue[NUMBEROFRECORDS] = {0};
  100. int         pkValue[NUMBEROFRECORDS] = {0};
  101. const int   tAttributeSize = 1 ;
  102. const int   nRecords = 20 ;
  103. int         bTestPassed = 0;
  104.   
  107. int main(int argc, const char** argv) {
  108.   ndb_init();
  110.   int operationType = 0;
  111.   int tupTest = 0;
  112.   int scanTest = 0;
  114.   Ndb* pNdb = new Ndb("TEST_DB");
  115.   pNdb->init();
  117.   if (argc != 4  ||  sscanf(argv[1],"%d", &operationType) != 1) {
  118.     operationType = 1 ;
  119.   }
  120.   if (argc != 4  ||  sscanf(argv[2],"%d", &tupTest) != 1) {
  121.     tupTest = 1 ;
  122.   }
  123.   if (argc != 4  ||  sscanf(argv[3],"%d", &scanTest) != 1) {
  124.     scanTest = 1 ;
  125.   }
  127.   ndbout << endl
  128.       << "Test the interpreter in TUP using SimpleTable withn"
  129.       << nRecords << " records" << endl << endl ;
  131.   if (pNdb->waitUntilReady(30) != 0) {
  132.     ndbout << "NDB is not ready" << endl;
  133.     return -1;
  134.   }
  136.   // Init the pk and attr values.
  137.   for (int i = 0; i < NUMBEROFRECORDS; i ++)
  138.     pkValue[i] = attrValue[i] = i ;
  140.   setAttrNames() ;
  141.   setTableNames() ;
  142.   
  143.   const void * p = NDBT_Table::discoverTableFromDb(pNdb, tableName);
  144.   if (p != 0){
  145.     create_table(pNdb);
  146.   }
  147.   
  148.   write_rows(pNdb);
  150.   ndbout << endl << "Starting interpreter in TUP test." << endl << "Operation type: " ;
  152.   switch(operationType) {
  153.   case 1:
  154.     ndbout << "openScanRead" << endl;
  155.     scan_rows(pNdb,  operationType,  tupTest,  scanTest);
  156.     break;
  157.   case 2:
  158.     ndbout << "openScanExclusive" << endl;
  159.     scan_rows(pNdb,  operationType,  tupTest,  scanTest);
  160.     break;
  161.   case 3:
  162.     ndbout << "interpretedUpdateTuple" << endl;
  163.     update_rows(pNdb,  tupTest,  operationType);
  164.     break;
  165.   case 4:
  166.     ndbout << "interpretedDirtyUpdate" << endl;
  167.     update_rows(pNdb,  tupTest,  operationType);
  168.     break;
  169.   case 5:
  170.     ndbout << "interpretedDeleteTuple" << endl;
  171.     delete_rows(pNdb,  tupTest,  operationType);
  172.     break;
  173.   case 6:
  174.     ndbout << "deleteTuple" << endl;
  175.     break;
  176.   case 7:
  177.     ndbout << "insertTuple" << endl;
  178.     break;
  179.   case 8:
  180.     ndbout << "updateTuple" << endl;
  181.     break;
  182.   case 9:
  183.     ndbout << "writeTuple" << endl;
  184.     break;
  185.   case 10:
  186.     ndbout << "readTuple" << endl;
  187.     break;
  188.   case 11:
  189.     ndbout << "readTupleExclusive" << endl;
  190.     break;
  191.   case 12:
  192.     ndbout << "simpleRead" << endl;
  193.     break;
  194.   case 13:
  195.     ndbout << "dirtyRead" << endl;
  196.     break;
  197.   case 14:
  198.     ndbout << "dirtyUpdate" << endl;
  199.     break;
  200.   case 15:
  201.     ndbout << "dirtyWrite" << endl;
  202.     break;
  203.   default:
  204.     break ;
  206.   }
  208. //  read_and_verify_rows(pNdb, false);
  210. //  delete_rows(pNdb, 0, 0) ;
  211.   delete pNdb ;
  213.   if (bTestPassed == 0) {
  214.       ndbout << "OK: test passed" << endl;
  215.       exit(0);
  216.   }else{
  217.       ndbout << "FAIL: test failed" << endl;
  218.       exit(-1);
  219.   }
  220. }
  222. void error_handler(const NdbError & err, TTYPE type_expected) {
  224.   ndbout << err << endl ;
  226.   switch (type_expected){
  227.       case NO_FAIL:
  228.           bTestPassed = -1 ;
  229.           break ;
  230.       case FAIL:
  231.           ndbout << "OK: error is expected" << endl;
  232.           break ;
  233.       case UNDEF:
  234.           ndbout << "assumed OK: expected result undefined" << endl ;
  235.           break ;
  236.       default:
  237.           break ;
  238.   }
  239. }
  241. void  create_table(Ndb* pMyNdb) {
  243.   /****************************************************************
  244.    *    Create SimpleTable and Attributes.
  245.    *
  246.    *    create table SimpleTable1(
  247.    *        col0 int,
  248.    *        col1 int not null,
  249.    *        col2 int not null,
  250.    *        col3 int not null ... 129)
  251.    *
  252.    ***************************************************************/
  254.   int               check = -1 ;
  255.   NdbSchemaOp       *MySchemaOp = NULL ;
  257.   ndbout << endl << "Creating " << tableName << " ... " << endl;
  259.    NdbSchemaCon* MySchemaTransaction = NdbSchemaCon::startSchemaTrans(pMyNdb);
  260.    if(!MySchemaTransaction) error_handler(MySchemaTransaction->getNdbError(), NO_FAIL);
  261.    
  262.    MySchemaOp = MySchemaTransaction->getNdbSchemaOp();
  263.    if( !MySchemaOp ) error_handler(MySchemaTransaction->getNdbError(), NO_FAIL);
  264.    // Create table
  265.    check = MySchemaOp->createTable( tableName,
  266.                                      8,         // Table size
  267.                                      TupleKey,  // Key Type
  268.                                      40         // Nr of Pages
  269.                                    );
  271.    if( check == -1 ) error_handler(MySchemaTransaction->getNdbError(), NO_FAIL);
  273.    ndbout << "Creating attributes ... " << flush;
  275.    // Create first column, primary key
  276.    check = MySchemaOp->createAttribute( attrName[0],
  277.                                         TupleKey,
  278.                                         32,
  279.                                         1/*3, tAttributeSize */,
  280.                                         UnSigned,
  281.                                         MMBased,
  282.                                         NotNullAttribute );
  284.    if( check == -1 ) error_handler(MySchemaTransaction->getNdbError(), NO_FAIL);
  286.    // create the 2 .. n columns.
  287.    for ( int i = 1; i < MAXATTR; i++ ){
  288.        check = MySchemaOp->createAttribute( attrName[i],
  289.                                             NoKey,
  290.                                             32,
  291.                                             tAttributeSize,
  292.                                             UnSigned,
  293.                                             MMBased,
  294.                                             NotNullAttribute );
  296.       if( check == -1 ) error_handler(MySchemaTransaction->getNdbError(), NO_FAIL);
  297.    }
  299.    ndbout << "OK" << endl;
  301.    if( MySchemaTransaction->execute() == -1 ) {
  302.        ndbout << MySchemaTransaction->getNdbError() << endl;
  303.    }else{
  304.        ndbout << tableName[0] << " created" << endl;
  305.    }
  308.    NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
  310.    return;
  312. }
  316. void write_rows (Ndb* pMyNdb) {
  318.   /****************************************************************
  319.    *    Insert rows into SimpleTable
  320.    *
  321.    ***************************************************************/
  323.   int check = -1 ;
  324.   int loop_count_ops = nRecords ;
  325.   NdbOperation      *MyOperation = NULL ;
  326.   NdbConnection     *MyTransaction = NULL ;
  328.   ndbout << endl << "Writing records ..."  << flush;
  330.   for (int count=0 ; count < loop_count_ops ; count++){
  331.       MyTransaction = pMyNdb->startTransaction();
  332.       if (!MyTransaction) {
  333.           error_handler(pMyNdb->getNdbError(), NO_FAIL);
  334.       }//if
  336.       MyOperation = MyTransaction->getNdbOperation(tableName);
  337.       if (!MyOperation) {
  338.         error_handler(pMyNdb->getNdbError(), NO_FAIL);
  339.       }//if
  341.       check = MyOperation->writeTuple();
  342.       if( check == -1 ) error_handler(MyTransaction->getNdbError(), NO_FAIL);
  344.       check = MyOperation->equal( attrName[0],(char*)&pkValue[count] );
  345.       if( check == -1 ) error_handler(MyTransaction->getNdbError(), NO_FAIL);
  347.       // Update the columns, index column already ok.
  348.       for (int i = 1 ; i < MAXATTR; i++){
  349.           if ((i == 2) && (count > 4)){
  350.               check = MyOperation->setValue(attrName[i], (char*)&attrValue[count + 1]);
  351.           }else{
  352.               check = MyOperation->setValue(attrName[i], (char*)&attrValue[count]);
  353.           }
  354.         if( check == -1 ) error_handler(MyTransaction->getNdbError(), NO_FAIL);
  355.       }
  356.       check = MyTransaction->execute( Commit );
  357.       if(check == -1 ) error_handler(MyTransaction->getNdbError(), NO_FAIL);
  358.       
  359.       pMyNdb->closeTransaction(MyTransaction);
  360.     }
  361.    ndbout <<" tOK" << endl;
  362.    return;
  363. }
  365. void verify_deleted(Ndb* pMyNdb) {
  367.   int               check = -1 ;
  368.   int               loop_count_ops = nRecords;
  369.   NdbOperation*     pMyOperation = NULL ;
  371.   ndbout << "Verifying deleted records..."<< flush;
  373.   for (int count=0 ; count < loop_count_ops ; count++){
  375.       NdbConnection*  pMyTransaction = pMyNdb->startTransaction();
  376.       if (!pMyTransaction) error_handler(pMyNdb->getNdbError(), NO_FAIL);
  377.       
  378.       pMyOperation = pMyTransaction->getNdbOperation(tableName);
  379.       if (!pMyOperation) error_handler(pMyNdb->getNdbError(), NO_FAIL);
  380.       
  381.       check = pMyOperation->readTuple();
  382.       if( check == -1 ) error_handler( pMyTransaction->getNdbError(), NO_FAIL);
  384.       check = pMyOperation->equal( attrName[0],(char*)&pkValue[count] );
  385.       if( check == -1 ) error_handler( pMyTransaction->getNdbError(), NO_FAIL);
  387.      // Exepect to receive an error
  388.      if(pMyTransaction->execute(Commit) != -1)
  389.          if( 626 == pMyTransaction->getNdbError().code){
  390.              ndbout << pMyTransaction->getNdbError() << endl ;
  391.              ndbout << "OK" << endl ;
  392.          }else{
  393.              error_handler(pMyTransaction->getNdbError(), NO_FAIL) ;
  394.          }
  396.      pMyNdb->closeTransaction(pMyTransaction);
  397.     }
  399.   ndbout << "OK" << endl;
  400.   return;
  401. };
  403. void read_and_verify_rows(Ndb* pMyNdb, bool pre) {
  405.   int               check = -1 ;
  406.   int               loop_count_ops = nRecords;
  407.   char              expectedCOL1[NUMBEROFRECORDS] = {0} ;
  408.   char              expectedCOL2[NUMBEROFRECORDS] = {0} ;
  409.   NdbConnection     *pMyTransaction = NULL ;
  410.   NdbOperation      *MyOp = NULL ;
  411.   NdbRecAttr*       tTmp = NULL ;
  412.   int               readValue[MAXATTR] = {0} ;
  414.   ndbout << "Verifying records...n"<< endl;
  416.   for (int count=0 ; count < loop_count_ops ; count++){
  417.       
  418.       pMyTransaction = pMyNdb->startTransaction();
  419.       if (!pMyTransaction) error_handler(pMyNdb->getNdbError(), NO_FAIL);
  421.       MyOp = pMyTransaction->getNdbOperation(tableName);
  422.       if (!MyOp) error_handler( pMyTransaction->getNdbError(), NO_FAIL);
  425.       check = MyOp->readTuple();
  426.       if( check == -1 ) error_handler( MyOp->getNdbError(), NO_FAIL);
  427.       
  428.       check = MyOp->equal( attrName[0],(char*)&pkValue[count] );
  429.       if( check == -1 ) error_handler( MyOp->getNdbError(), NO_FAIL);
  431.       for (int count_attributes = 1; count_attributes < MAXATTR; count_attributes++){
  432.           
  433.           tTmp = MyOp->getValue( (char*)attrName[count_attributes], (char*)&readValue[count_attributes] );
  434.           if(!tTmp) error_handler( MyOp->getNdbError(), NO_FAIL);
  435.       }
  437.       if( pMyTransaction->execute( Commit ) == -1 ) {
  438.          error_handler(pMyTransaction->getNdbError(), NO_FAIL);
  439.       } else {
  440.         if (pre) {
  441.           expectedCOL1[count] = readValue[1];
  442.           expectedCOL2[count] = readValue[2];
  443.         }
  444.         
  445.         ndbout << attrName[1] << "t " << readValue[1] << "t "
  446.              << attrName[2] << "t " << readValue[2] << endl;
  447.       }
  449.       pMyNdb->closeTransaction(pMyTransaction);
  451.   }
  453.   ndbout << "nOKn" << endl;
  455.   return;
  457. };
  459. TTYPE t_exitMethods(int nCalls, NdbOperation * pOp, int opType) {
  461.   ndbout << "Defining exitMethods test " << nCalls << ": " << endl ;;
  462.   TTYPE ret_val = NO_FAIL ;
  464.   switch(nCalls){
  465.   case 1: // exit_nok if attr value matches
  466.     pOp->read_attr("COL1", 1);
  467.     pOp->load_const_u32(2, 14);
  468.     pOp->branch_eq(1, 2, 0);
  469.     pOp->interpret_exit_ok() ;
  470.     pOp->def_label(0);
  471.     pOp->interpret_exit_nok();
  472.     break;
  473.   case 2: // exit_ok if attr value doesn't match
  474.     pOp->read_attr("COL1", 1);
  475.     pOp->load_const_u32(2, 14);
  476.     pOp->branch_eq(1, 2, 0);
  477.     pOp->interpret_exit_nok() ;
  478.     pOp->def_label(0);
  479.     if (opType == 3) {
  480.       // For update transactions use incValue to update the tuple
  481.       Uint32 val32 = 5;
  482.       pOp->incValue("COL2", val32);
  483.     }
  484.     pOp->interpret_exit_ok();
  485.     break ;
  486.   case 3: // Non-existent value (128): exit_ok if if the value matches
  487.     pOp->read_attr("COL1", 1);
  488.     pOp->load_const_u32(2, 128);
  489.     pOp->branch_eq(1, 2, 0);
  490.     pOp->interpret_exit_nok();
  491.     pOp->def_label(0);
  492.     pOp->interpret_exit_ok();
  493. ret_val = FAIL ;
  494.     break;
  495.   case 4: // Non-existent value (128): exit_nok if the value matches
  496.     pOp->read_attr("COL1", 1);
  497.     pOp->load_const_u32(2, 128);
  498.     pOp->branch_eq(1, 2, 0);
  499.     pOp->interpret_exit_ok();
  500.     pOp->def_label(0);
  501.     pOp->interpret_exit_nok();
  502. ret_val = FAIL ;
  503.     break;
  504.   case 5: // exit_nok of the value matches
  505.     pOp->read_attr("COL1", 1);
  506.     pOp->load_const_u32(2, 2);
  507.     pOp->branch_eq(1, 2, 0);
  508.     pOp->interpret_exit_ok();
  509.     pOp->def_label(0);
  510.     pOp->interpret_exit_nok();
  511.     break ;
  512.   case 6: // exit_ok of the value matches
  513.     pOp->read_attr("COL1", 1);
  514.     pOp->load_const_u32(2, 2);
  515.     pOp->branch_eq(1, 2, 0);
  516.     pOp->interpret_exit_nok();
  517.     pOp->def_label(0);
  518.     if (opType == 3) {
  519.       // For update transactions use incValue to update the tuple
  520.       Uint32 val32 = 5;
  521.       pOp->incValue("COL2", val32);
  522.     }
  523.     pOp->interpret_exit_ok();
  524.     break;
  525.   case 7: // exit_nok if the value matches
  526.     pOp->read_attr("COL1", 1);
  527.     pOp->load_const_u32(2, 6);
  528.     pOp->branch_eq(1, 2, 0);
  529.     pOp->interpret_exit_ok();
  530.     pOp->def_label(0);
  531.     pOp->interpret_exit_nok();
  532.     break;
  533.   case 8: // exit_ok if the value matches
  534.     pOp->read_attr("COL1", 1);
  535.     pOp->load_const_u32(2, 6);
  536.     pOp->branch_ne(1, 2, 0);
  537.     pOp->interpret_exit_nok();
  538.     pOp->def_label(0);
  539.     if (opType == 3) {
  540.       // For update transactions use incValue to update the tuple
  541.       Uint32 val32 = 5;
  542.       pOp->incValue("COL2", val32);
  543.     }
  544.     pOp->interpret_exit_ok();
  545.     break ;
  546.   case 9: // exit_nok if the value matches
  547.     pOp->read_attr("COL1", 1);
  548.     pOp->load_const_u32(2, 8);
  549.     pOp->branch_eq(1, 2, 0);
  550.     pOp->interpret_exit_ok();
  551.     pOp->def_label(0);
  552.     pOp->interpret_exit_nok();
  553.     break;
  554.   case 10: // exit_ok if the value matches
  555.     pOp->read_attr("COL1", 1);
  556.     pOp->load_const_u32(2, 8);
  557.     pOp->branch_eq(1, 2, 0);
  558.     pOp->interpret_exit_nok();
  559.     pOp->def_label(0);
  560.     if (opType == 3) {
  561.       // For update transactions use incValue to update the tuple
  562.       Uint32 val32 = 5;
  563.       pOp->incValue("COL2", val32);
  564.     }
  565.     pOp->interpret_exit_ok();
  566.     break;
  567.   case 11: // exit_nok if the value matches
  568.     pOp->read_attr("COL1", 1);
  569.     pOp->load_const_u32(2, 10);
  570.     pOp->branch_eq(1, 2, 0);
  571.     pOp->interpret_exit_ok();
  572.     pOp->def_label(0);
  573.     pOp->interpret_exit_nok();
  574.     break;
  575.   case 12:
  576.     pOp->read_attr("COL1", 1);
  577.     pOp->load_const_u32(2, 10);
  578.     pOp->branch_eq(1, 2, 0);
  579.     pOp->interpret_exit_nok();
  580.     pOp->def_label(0);
  581.     if (opType == 3) {
  582.       // For update transactions use incValue to update the tuple
  583.       Uint32 val32 = 5;
  584.       pOp->incValue("COL2", val32);
  585.     }
  586.     pOp->interpret_exit_ok();
  587.     break;
  588.   case 13:
  589.     pOp->read_attr("COL1", 1);
  590.     pOp->load_const_u32(2, 10);
  591.     pOp->branch_eq(1, 2, 0);
  592.     pOp->interpret_exit_ok();
  593.     pOp->def_label(0);
  594.     pOp->interpret_exit_nok();
  595.     break;
  596.   case 14: // exit_nok if the value matches
  597.     pOp->read_attr("COL1", 1);
  598.     pOp->load_const_u32(2, 12);
  599.     pOp->branch_eq(1, 2, 0);
  600.     pOp->interpret_exit_ok();
  601.     pOp->def_label(0);
  602.     pOp->interpret_exit_nok();
  603.     break;
  604.   case 15: // exit_ok if the value matches
  605.     pOp->read_attr("COL1", 1);
  606.     pOp->load_const_u32(2, 12);
  607.     pOp->branch_eq(1, 2, 0);
  608.     pOp->interpret_exit_nok();
  609.     pOp->def_label(0);
  610.     if (opType == 3) {
  611.       // For update transactions use incValue to update the tuple
  612.       Uint32 val32 = 5;
  613.       pOp->incValue("COL2", val32);
  614.     }
  615.     pOp->interpret_exit_ok();
  616.   case 16:
  617.     pOp->interpret_exit_nok();
  618.     ret_val = FAIL ;
  619.     break;
  620.   case 17:
  621.     pOp->interpret_exit_ok();
  622.     break ;
  623.   case 18:
  624.     pOp->interpret_exit_nok();
  625.     ret_val = FAIL ;
  626.     break ;
  627.   default:
  628.     break ;
  629.   }
  630.   return ret_val;
  631. }
  633. TTYPE t_incValue(int nCalls, NdbOperation* pOp) {
  635.   ndbout << "Defining incValue test " << nCalls << ": ";
  636.   TTYPE ret_val = NO_FAIL;
  638.   Uint32 val32 = 5;
  639.   Uint64 val64 = 5;
  640.   Uint32 attr0 = 0;
  641.   Uint32 attr1 = 1;
  642.   Uint32 attr20 = 20;
  644.   switch(nCalls) {
  645.   case 1:
  646.     pOp->incValue(attrName[1], val32);
  647.     break;
  648.   case 2:
  649.     pOp->incValue(attr1, val32);
  650.     break;
  651.   case 3:
  652.     pOp->incValue(attrName[1], val64);
  653.     break;
  654.   case 4:
  655.     pOp->incValue(attr1, val64);
  656.     break;
  657.   case 5:
  658.     pOp->incValue(attrName[0], val32);
  659.     ret_val = FAIL ;
  660.     break;
  661.   case 6:
  662.     pOp->incValue(attrName[0], val64);
  663.     ret_val = FAIL ;
  664.     break;
  665.   case 7:
  666.     pOp->incValue(attr0, val32);
  667.     ret_val = FAIL ;
  668.     break;
  669.   case 8:
  670.     pOp->incValue(attr0, val64);
  671.     ret_val = FAIL ;
  672.     break;
  673.   case 9:
  674.     pOp->incValue("COL20", val32);
  675.     ret_val = FAIL ;
  676.     break;
  677.   case 10:
  678.     pOp->incValue("COL20", val64);
  679.     ret_val = FAIL ;
  680.     break;
  681.   case 11:
  682.     pOp->incValue(attr20, val32);
  683.     ret_val = FAIL ;
  684.     break;
  685.   case 12:
  686.     pOp->incValue(attr20, val64);
  687.     ret_val = FAIL ;
  688.     break;
  689.   default:
  690.       break ;
  691.   }
  692.   return ret_val;
  693. }
  695. TTYPE t_subValue(int nCalls, NdbOperation* pOp) {
  697.   ndbout << "Defining subValue test " << nCalls << ": ";
  699.   Uint32 val32 = 5;
  700.   Uint64 val64 = 5;
  701.   Uint32 attr0 = 0;
  702.   Uint32 attr1 = 1;
  703.   Uint32 attr20 = 20;
  705.   TTYPE ret_val = NO_FAIL;
  707.   switch(nCalls) {
  708.   case 1:
  709.     pOp->subValue("COL2", val32);
  710.     break;
  711.   case 2:
  712.     pOp->subValue(attr1, val32);
  713.     break;
  714.   case 3:
  715.     pOp->subValue("COL0", val32);
  716.     ret_val = FAIL ;
  717.     break;
  718.   case 4:
  719.     pOp->subValue(attr0, val32);
  720.     ret_val = FAIL ;
  721.     break;
  722.   case 5:
  723.     pOp->subValue("COL20", val32);
  724.     ret_val = FAIL ;
  725.     break;
  726.   case 6:
  727.     pOp->subValue(attr20, val32);
  728.     ret_val = FAIL ;
  729.     break;
  730.   case 7:
  731.     // Missing implementation
  732.     //pOp->subValue("COL20", val64);
  733.     ndbout << "Missing implementation" << endl;
  734.     break;
  735.   case 8:
  736.     // Missing implementation
  737.     //pOp->subValue("COL2", val64);
  738.     ndbout << "Missing implementation" << endl;
  739.     break;
  740.   case 9:
  741.     // Missing implementation
  742.     //pOp->subValue("COL0", val64);
  743.     ndbout << "Missing implementation" << endl;
  744.     break;
  745.   case 10:
  746.     // Missing implementation
  747.     //pOp->subValue(attr1, val64);
  748.     ndbout << "Missing implementation" << endl;
  749.     break;
  750.   case 11:
  751.     // Missing implementation
  752.     //pOp->subValue(attr0, val64);
  753.     ndbout << "Missing implementation" << endl;
  754.     break;
  755.   case 12:
  756.     // Missing implementation
  757.     //pOp->subValue(attr20, val64);
  758.     ndbout << "Missing implementation" << endl;
  759.     break;
  760.   default:
  761.       break ;
  762.   }
  763.   return ret_val ;
  764. }
  766. TTYPE t_readAttr(int nCalls, NdbOperation* pOp) {
  768.   ndbout << "Defining readAttr test " << nCalls << ": ";
  770.   Uint32 attr0 = 0;
  771.   Uint32 attr1 = 1;
  772.   Uint32 attr20 = 20;
  773.   TTYPE ret_val = NO_FAIL;
  775.   switch(nCalls) {
  776.   case 1:
  777.     pOp->read_attr("COL1", 1);
  778.     break;
  779.   case 2:
  780.     pOp->read_attr(attr1, 1);
  781.     ret_val = NO_FAIL ;
  782.     break;
  783.   case 3:
  784.     pOp->read_attr("COL0", 1);
  785.     ret_val = NO_FAIL ;
  786.     break;
  787.   case 4:
  788.     pOp->read_attr(attr0, 1);
  789.     ret_val = NO_FAIL ;
  790.     break;
  791.   case 5:
  792.     pOp->read_attr("COL20", 1);
  793.     ret_val = FAIL ;
  794.     break;
  795.   case 6:
  796.     pOp->read_attr(20, 1);
  797.     ret_val = FAIL ;
  798.     break;
  799.   case 7:
  800.     pOp->read_attr("COL1", 8);
  801.     ret_val = FAIL ;
  802.     break;
  803.   case 8:
  804.     pOp->read_attr(attr1, 8);
  805.     ret_val = FAIL ;
  806.     break;
  807.   default:
  808.       break ;
  809.   }
  810.   return ret_val;
  811. }
  813. TTYPE t_writeAttr(int nCalls, NdbOperation* pOp) {
  815.   ndbout << "Defining writeAttr test " << nCalls << ": ";
  817.   pOp->load_const_u32(1, 5);
  819.   Uint32 attr0 = 0;
  820.   Uint32 attr1 = 1;
  821.   Uint32 attr20 = 20;
  822.   TTYPE ret_val = NO_FAIL ;
  824.   switch(nCalls) {
  825.   case 1:
  826.     pOp->write_attr("COL1", 1);
  827.     break;
  828.   case 2:
  829.     pOp->write_attr(attr1, 1);
  830.     break;
  831.   case 3:
  832.     pOp->write_attr("COL0", 1);
  833.     ret_val = FAIL ;
  834.     break;
  835.   case 4:
  836.     pOp->write_attr(attr0, 1);
  837.     ret_val = FAIL ;
  838.     break;
  839.   case 5:
  840.     pOp->write_attr("COL20", 1);
  841.     ret_val = FAIL ;
  842.     break;
  843.   case 6:
  844.     pOp->write_attr(20, 1);
  845.     ret_val = FAIL ;
  846.     break;
  847.   case 7:
  848.     pOp->write_attr("COL1", 2);
  849.     ret_val = FAIL ;
  850.     break;
  851.   case 8:
  852.     pOp->write_attr(attr1, 2);
  853.     ret_val = FAIL ;
  854.     break;
  855.   case 9:
  856.     pOp->write_attr("COL1", 8);
  857.     ret_val = FAIL ;
  858.     break;
  859.   case 10:
  860.     pOp->write_attr(attr1, 8);
  861.     ret_val = FAIL ;
  862.     break;
  863.   default:
  864.       break ;
  865.   }
  866.   return ret_val ;
  867. }
  869. TTYPE t_loadConst(int nCalls, NdbOperation* pOp, int opType) {
  871.   ndbout << "Defining loadConst test " << nCalls << " : ";
  872.   TTYPE ret_val = NO_FAIL ;
  874.   switch(nCalls) {
  875.   case 1:
  876.     // Loading null into a valid register
  877.     pOp->load_const_null(1);
  878.     break;
  879.   case 2:
  880.     // Loading null into an invalid register
  881.     pOp->load_const_null(8);
  882.     ret_val = FAIL ;
  883.     break;
  884.   case 3:
  885.     // Test loading a 32-bit value (>65536)
  886.     pOp->load_const_u32(1, 65600);
  887.     break;
  888.   case 4:
  889.     // Test loading a 16-bit value (<65536)
  890.     pOp->load_const_u32(1, 65500);
  891.     break;
  892.   case 5:
  893.     // Test by loading to a non-valid register
  894.     pOp->load_const_u32(8, 2);
  895.     ret_val = FAIL ;
  896.     break;
  897.   case 6:
  898.     // Test by loading a 64-bit value
  899.     pOp->load_const_u64(1, 65600);
  900.     break;
  901.   case 7:
  902.     // Test by loading a non-valid register
  903.     pOp->load_const_u64(8, 2);
  904.     ret_val = FAIL ;
  905.     break;
  906.   case 8:
  907.     // Test by loading a valid register with -1
  908.     pOp->load_const_u64(1, -1);
  909.     ret_val = FAIL ;
  910.     break;
  912.   default:
  913.       break ;
  914.   }
  916.   if (opType == 3 && FAIL != ret_val)
  917.     pOp->write_attr("COL1", 1);
  918.   return ret_val;
  919. }
  921. TTYPE t_branch(int nCalls, NdbOperation* pOp) {
  923.   ndbout << "Defining branch test " << nCalls << ": " ;
  924.   
  925.   TTYPE ret_val = NO_FAIL ;
  926.   Uint32 val32=5;
  928.   pOp->read_attr("COL1", 1);
  929.   pOp->load_const_u32(2, val32);
  931.   switch(nCalls) {
  932.   case 1:
  933.     pOp->branch_eq(1, 2, 0);
  934.     pOp->interpret_exit_nok();
  935.     pOp->def_label(0);
  936.     pOp->interpret_exit_ok();
  937.     break;
  938.   case 2:
  939.     pOp->branch_eq(2, 1, 0);
  940.     pOp->interpret_exit_nok();
  941.     pOp->def_label(0);
  942.     pOp->interpret_exit_ok();
  943.     break;
  944.   case 3:
  945.     pOp->branch_eq(1, 1, 0);
  946.     pOp->interpret_exit_nok();
  947.     pOp->def_label(0);
  948.     pOp->interpret_exit_ok();
  949.     break;
  950.   default:
  951.       //ndbout << "t_branch: default case (no test case)" << endl ;
  952.       //return ret_val = NO_FAIL ;
  953.       break ;
  954.   }
  955.   return ret_val;
  956. }
  958. TTYPE t_branchIfNull(int nCalls, NdbOperation* pOp) {
  960.   TTYPE ret_val = NO_FAIL;
  961.   ndbout << "Defining branchIfNull test " << nCalls << ": " << endl ;
  963.   switch(nCalls) {
  964.   case 1:
  965.     pOp->load_const_u32(1, 1);
  966.     pOp->branch_ne_null(1, 0);
  967.     pOp->interpret_exit_nok();
  968.     pOp->def_label(0);
  969.     pOp->interpret_exit_ok();
  970.     break;
  971.   case 2:
  972.     pOp->load_const_null(1);
  973.     pOp->branch_ne_null(1, 0);
  974.     pOp->interpret_exit_ok();
  975.     pOp->def_label(0);
  976.     pOp->interpret_exit_nok();
  977.     break;
  978.   case 3:
  979.     pOp->load_const_u32(1, 1);
  980.     pOp->branch_eq_null(1, 0);
  981.     pOp->interpret_exit_ok();
  982.     pOp->def_label(0);
  983.     pOp->interpret_exit_nok();
  984.     break;
  985.   case 4:
  986.     pOp->load_const_null(1);
  987.     pOp->branch_ne_null(1, 0);
  988.     pOp->interpret_exit_ok();
  989.     pOp->def_label(0);
  990.     pOp->interpret_exit_nok();
  991.     break;
  992.   case 5:
  993.     // Test with a non-initialized register
  994.     pOp->branch_ne_null(3, 0);
  995.     pOp->interpret_exit_ok();
  996.     pOp->def_label(0);
  997.     pOp->interpret_exit_nok();
  998.     ret_val = FAIL ;
  999.     break;
  1000.   case 6:
  1001.     // Test with a non-existing register
  1002.     pOp->branch_ne_null(8, 0);
  1003.     pOp->interpret_exit_ok();
  1004.     pOp->def_label(0);
  1005.     pOp->interpret_exit_nok();
  1006.     ret_val = FAIL ;
  1007.     break;
  1008.   case 7:
  1009.     // Test with a non-initialized register
  1010.     pOp->branch_eq_null(3, 0);
  1011.     pOp->interpret_exit_ok();
  1012.     pOp->def_label(0);
  1013.     pOp->interpret_exit_nok();
  1014.     ret_val = FAIL ;
  1015.     break;
  1016.   case 8:
  1017.     // Test with a non-existing register
  1018.     pOp->branch_ne_null(8, 0);
  1019.     pOp->interpret_exit_ok();
  1020.     pOp->def_label(0);
  1021.     pOp->interpret_exit_nok();
  1022.     ret_val = FAIL ;
  1023.     break;
  1024.   default:
  1025.       break ;
  1026.   }
  1028.   return ret_val;
  1029. }
  1031. TTYPE t_addReg(int nCalls, NdbOperation* pOp) {
  1033.   TTYPE ret_val = NO_FAIL ;
  1034.   
  1035.   ndbout << "Defining addReg test " << nCalls << ": ";
  1037.   pOp->load_const_u32(1, 65500);
  1038.   pOp->load_const_u32(2, 500);
  1039.   pOp->load_const_u64(3, 65600);
  1040.   pOp->load_const_u64(4, 95600);
  1042.   switch(nCalls) {
  1043.   case 1:
  1044.     pOp->add_reg(1, 2, 5);
  1045.     break;
  1046.   case 2:
  1047.     pOp->add_reg(1, 3, 5);
  1048.     break;
  1049.   case 3:
  1050.     pOp->add_reg(3, 1, 5);
  1051.     break;
  1052.   case 4:
  1053.     pOp->add_reg(3, 4, 5);
  1054.     break;
  1055.   case 5:
  1056.     pOp->add_reg(1, 6, 5);
  1057.     break;
  1058.   case 6:
  1059.     pOp->add_reg(6, 1, 5);
  1060.     break;
  1061.   case 7: // illegal register
  1062.     pOp->add_reg(1, 8, 5);
  1063.     ret_val = FAIL ;
  1064.     break;
  1065.   case 8: // another illegal register
  1066.     pOp->add_reg(8, 1, 5); 
  1067.     ret_val = FAIL ;
  1068.     break;
  1069.   case 9: // and another one
  1070.     pOp->add_reg(1, 2, 8);
  1071.     ret_val = FAIL ;
  1072.     break;
  1073.   default:
  1074.     break ;
  1075.   }
  1076.   pOp->load_const_u32(7, 65000);
  1077.   pOp->branch_eq(5, 7, 0);
  1078.   pOp->interpret_exit_nok();
  1079.   pOp->def_label(0);
  1080.   pOp->interpret_exit_ok();
  1082.   return ret_val ;
  1083. }
  1085. TTYPE t_subReg(int nCalls, NdbOperation* pOp) {
  1087.   TTYPE ret_val = NO_FAIL ;
  1088.   ndbout << "Defining subReg test: " << nCalls << endl;
  1090.   pOp->load_const_u32(1, 65500);
  1091.   pOp->load_const_u32(2, 500);
  1092.   pOp->load_const_u64(3, 65600);
  1093.   pOp->load_const_u64(4, 95600);
  1095.   switch(nCalls) {
  1096.   case 1:
  1097.     pOp->sub_reg(1, 2, 5);
  1098.     pOp->load_const_u32(7, 65000);
  1099.     break;
  1100.   case 2:
  1101.     pOp->sub_reg(1, 3, 5);
  1102.     pOp->load_const_u64(7, (Uint64)-100);
  1103.     break;
  1104.   case 3:
  1105.     pOp->sub_reg(3, 1, 5);
  1106.     pOp->load_const_u64(7, (Uint64)100);
  1107.     break;
  1108.   case 4:
  1109.     pOp->sub_reg(3, 4, 5);
  1110.     pOp->load_const_u64(7, (Uint64)-30000);
  1111.     break;
  1112.   case 5:
  1113.     pOp->sub_reg(1, 6, 5);
  1114.     pOp->load_const_u64(7, 0);
  1115.     ret_val = FAIL ;
  1116.     break;
  1117.   case 6:
  1118.     pOp->sub_reg(6, 1, 5);
  1119.     pOp->load_const_u64(7, 0);
  1120.     ret_val = FAIL ;
  1121.     break;
  1122.   case 7:
  1123.     pOp->sub_reg(1, 8, 5);
  1124.     pOp->load_const_u64(7, 0);
  1125.     ret_val = FAIL ;
  1126.     break;
  1127.   case 8:
  1128.     pOp->sub_reg(8, 1, 5);
  1129.     pOp->load_const_u64(7, 0);
  1130.     ret_val = FAIL ;
  1131.     break;
  1132.   case 9:
  1133.     pOp->sub_reg(1, 2, 8);
  1134.     pOp->load_const_u32(7, (Uint32)65000);
  1135.     ret_val = FAIL;
  1136.     break;
  1137.   default:
  1138.       //ndbout << "t_subReg: default case (no test case)" << endl ;
  1139.       //return ret_val = NO_FAIL ;
  1140.       break ;
  1141.   }
  1142.   pOp->branch_eq(5, 7, 0);
  1143.   pOp->interpret_exit_nok() ;
  1144.   pOp->def_label(0);
  1145.   pOp->interpret_exit_ok() ;
  1147.   return ret_val;
  1148. }
  1150. TTYPE t_subroutineWithBranchLabel(int nCalls, NdbOperation* pOp) {
  1152.   TTYPE ret_val = NO_FAIL ;
  1153.   ndbout << "Defining subroutineWithBranchLabel test:" << nCalls << endl;
  1155.   pOp->load_const_u32(1, 65500);
  1156.   pOp->load_const_u32(2, 500);
  1157.   pOp->load_const_u64(3, 65600);
  1158.   pOp->load_const_u64(4, 95600);
  1159.   pOp->load_const_u32(7, 65000);
  1160.   pOp->call_sub(0) ;
  1162.   switch(nCalls) {
  1163.   case 1:
  1164.     pOp->def_subroutine(0) ;
  1165.     pOp->add_reg(1, 2, 5);
  1166.     break;
  1167.   case 2:
  1168.     pOp->def_subroutine(0) ;
  1169.     pOp->add_reg(1, 3, 5);
  1170.     break;
  1171.   case 3:
  1172.     pOp->def_subroutine(0) ;
  1173.     pOp->add_reg(3, 1, 5);
  1174.     break;
  1175.   case 4:
  1176.     pOp->def_subroutine(0) ;
  1177.     pOp->add_reg(3, 4, 5);
  1178.     break;
  1179.   case 5:
  1180.     pOp->def_subroutine(0) ;
  1181.     pOp->add_reg(1, 6, 5);
  1182.     break;
  1183.   case 6:
  1184.     pOp->def_subroutine(0) ;
  1185.     pOp->add_reg(6, 1, 5);
  1186.     break;
  1187.   case 7: // illegal register
  1188.     pOp->def_subroutine(0) ;
  1189.     pOp->add_reg(1, 8, 5);
  1190.     ret_val = FAIL ;
  1191.     break;
  1192.   case 8: // another illegal register
  1193.     pOp->def_subroutine(0) ;
  1194.     pOp->add_reg(8, 1, 5); 
  1195.     ret_val = FAIL ;
  1196.     break;
  1197.   case 9: // and another one
  1198.     pOp->def_subroutine(0) ;
  1199.     pOp->add_reg(1, 2, 8);
  1200.     ret_val = FAIL ;
  1201.     break;
  1202.   case 10: // test subroutine nesting
  1203.       for(int sub = 0; sub < 25 ; ++sub){
  1204.           pOp->call_sub(sub) ;
  1205.           pOp->def_subroutine(sub + 1) ;
  1206.           pOp->interpret_exit_ok() ;
  1207.           pOp->ret_sub() ;
  1208.       }
  1209.     ret_val = FAIL ;
  1210.   default:
  1211.     break ;
  1212.   }
  1213.   
  1214.   pOp->branch_label(0) ;
  1215.   pOp->interpret_exit_nok() ;
  1216.   pOp->def_label(0) ;
  1217.   pOp->interpret_exit_ok() ;
  1218.   pOp->ret_sub() ;
  1220.   return ret_val ;
  1221. }
  1224. void scan_rows(Ndb* pMyNdb, int opType, int tupleType, int scanType) {
  1226.   int           check = -1 ; 
  1227.   int           loop_count_ops = nRecords ;
  1228.   int           eOf = -1 ;
  1229.   int           readValue = 0 ;
  1230.   int           readValue2 = 0 ;
  1231.   int           scanCount = 0 ;
  1232.   TTYPE         fail = NO_FAIL ;
  1234.   for (int count=0 ; count < loop_count_ops ; count++)    {
  1235.   NdbConnection* MyTransaction = pMyNdb->startTransaction();
  1236.   if (!MyTransaction) error_handler(pMyNdb->getNdbError(), NO_FAIL);
  1238.   NdbOperation*  MyOperation = MyTransaction->getNdbOperation(tableName);
  1239.   if (!MyOperation) error_handler(pMyNdb->getNdbError(), NO_FAIL);
  1241.   if (opType == 1)
  1242.     // Open for scan read, Creates the SCAN_TABREQ and if needed
  1243.     // SCAN_TABINFO signals.
  1244.     check = MyOperation->openScanRead(1);
  1245.   else if (opType == 2)
  1246.     // Open for scan with update of rows.
  1247.     check = MyOperation->openScanExclusive(1);
  1249.   // Create ATTRINFO signal(s) for interpreted program used for
  1250.   // defining search criteria and column values that should be returned.
  1252.   scanCount = count+1 ;
  1254.   switch(tupleType) {
  1255.   case 1:
  1256.     fail = t_exitMethods(scanCount, MyOperation,  opType);
  1257.     break;
  1258.   case 2:
  1259.     fail = t_incValue(scanCount, MyOperation);
  1260.     break;
  1261.   case 3:
  1262.     fail = t_subValue(scanCount, MyOperation);
  1263.     break;
  1264.   case 4:
  1265.     fail = t_readAttr(scanCount, MyOperation);
  1266.     break;
  1267.   case 5:
  1268.     fail = t_writeAttr(scanCount, MyOperation);
  1269.     break;
  1270.   case 6:
  1271.     fail = t_loadConst(scanCount, MyOperation,  opType);
  1272.     break;
  1273.   case 7:
  1274.     fail = t_branch(scanCount, MyOperation);
  1275.     break;
  1276.   case 8:
  1277.     fail = t_branchIfNull(scanCount, MyOperation);
  1278.     break;
  1279.   case 9:
  1280.     fail = t_addReg(scanCount, MyOperation);
  1281.     break;
  1282.   case 10:
  1283.     fail = t_subReg(scanCount, MyOperation);
  1284.     break;
  1285.   case 11:
  1286.     fail = t_subroutineWithBranchLabel(scanCount, MyOperation);
  1287.     break;
  1288.   default:
  1289.     break ;
  1290.   }
  1292.   if(11 != tupleType) MyOperation->getValue(attrName[1], (char*)&readValue);
  1294.   // Sends the SCAN_TABREQ, (SCAN_TABINFO) and ATTRINFO signals and then
  1295.   // reads the answer in TRANSID_AI. Confirmation is received through SCAN_TABCONF or
  1296.   // SCAN_TABREF if failure.
  1297.   check = MyTransaction->executeScan();
  1298.   if (check == -1) {
  1299.     //ndbout << endl << "executeScan returned: " << MyTransaction->getNdbError() << endl;
  1300.       error_handler(MyTransaction->getNdbError(), fail) ;
  1301.   pMyNdb->closeTransaction(MyTransaction);
  1302.   }else{
  1303.     // Sends the SCAN_NEXTREQ signal(s) and reads the answer in TRANS_ID signals.
  1304.     // SCAN_TABCONF or SCAN_TABREF is the confirmation.
  1305.     while ((eOf = MyTransaction->nextScanResult()) == 0) {
  1306.       ndbout << readValue <<"; ";
  1307.       // Here we call takeOverScanOp for update of the tuple.
  1308.     }
  1309.     ndbout << endl ;
  1311.     pMyNdb->closeTransaction(MyTransaction);
  1312.     if (eOf == -1) {
  1313.       ndbout << endl << "nextScanResult returned: "<< MyTransaction->getNdbError() << endl;
  1314.     } else {
  1315.       ndbout << "OK" << endl;
  1316.     }
  1317.   }
  1318.   }
  1319.   return;
  1321. };
  1324. void  update_rows(Ndb* pMyNdb, int tupleType, int opType) {
  1325.    /****************************************************************
  1326.    *    Update rows in SimpleTable
  1327.    *    Only updates the first 3 cols.
  1328.    ***************************************************************/
  1330.   int check = -1 ;
  1331.   int loop_count_ops = nRecords ;
  1332.   int readValue[MAXATTR] = {0} ;
  1333.   TTYPE ret_val = NO_FAIL ;
  1334.   NdbConnection     *MyTransaction = NULL ;
  1335.   NdbOperation      *MyOperation = NULL ;
  1337.   ndbout << "Updating records ..." << endl << endl;
  1339.   for (int count=0 ; count < loop_count_ops ; count++){
  1341.     MyTransaction = pMyNdb->startTransaction();
  1342.     if (!MyTransaction) {
  1343.       error_handler(pMyNdb->getNdbError(), NO_FAIL);
  1344.       return;
  1345.     }//if
  1347.     MyOperation = MyTransaction->getNdbOperation(tableName);
  1348.     if (MyOperation == NULL) {
  1349.       error_handler(pMyNdb->getNdbError(), NO_FAIL);
  1350.       return;
  1351.     }//if
  1353.     //   if (operationType == 3)
  1354.     check = MyOperation->interpretedUpdateTuple();
  1355.     // else if (operationType == 4)
  1356.     // check = MyOperation->interpretedDirtyUpdate();
  1357.     if( check == -1 )
  1358.       error_handler(MyTransaction->getNdbError(), NO_FAIL);
  1360.     check = MyOperation->equal( attrName[0], (char*)&pkValue[count] );
  1361.     if( check == -1 )
  1362.       error_handler(MyTransaction->getNdbError(), NO_FAIL);
  1364.     switch(tupleType) {
  1365.     case 1:
  1366.       ret_val = t_exitMethods(count+1, MyOperation,  opType);
  1367.       break;
  1368.     case 2:
  1369.       ret_val = t_incValue(count+1, MyOperation);
  1370.       break;
  1371.     case 3:
  1372.       ret_val = t_subValue(count+1, MyOperation);
  1373.       break;
  1374.     case 4:
  1375.       ret_val = t_readAttr(count+1, MyOperation);
  1376.       break;
  1377.     case 5:
  1378.       ret_val = t_writeAttr(count+1, MyOperation);
  1379.       break;
  1380.     case 6:
  1381.       ret_val = t_loadConst(count+1, MyOperation,  opType);
  1382.       break;
  1383.     case 7:
  1384.       ret_val = t_branch(count+1, MyOperation);
  1385.       break;
  1386.     case 8:
  1387.       ret_val = t_branchIfNull(count+1, MyOperation);
  1388.       break;
  1389.     case 9:
  1390.       ret_val = t_addReg(count+1, MyOperation);
  1391.       break;
  1392.     case 10:
  1393.       ret_val = t_subReg(count+1, MyOperation);
  1394.       break;
  1395.     case 11:
  1396.       ret_val = t_subroutineWithBranchLabel(count+1, MyOperation);
  1397.       break;
  1398.     default:
  1399.         break ;
  1400.     }
  1402.     MyOperation->getValue("COL1", (char*)&readValue);
  1404.     if (MyTransaction->execute( Commit ) == -1 ) {
  1405.        error_handler(MyTransaction->getNdbError(), ret_val);
  1406.     }else if (NO_FAIL == ret_val ) {
  1407.       ndbout << "OK" << endl;
  1408.     } else {
  1409.       bTestPassed = -1;
  1410.       ndbout << "Test passed when expected to fail" << endl;
  1411.     }//if
  1412.     pMyNdb->closeTransaction(MyTransaction);
  1414.   }
  1416.   ndbout << "Finished updating records" << endl;
  1417.   return;
  1418. };
  1420. void delete_rows(Ndb* pMyNdb, int tupleTest, int opType) {
  1422.   /****************************************************************
  1423.    *    Delete rows from SimpleTable
  1424.    *
  1425.    ***************************************************************/
  1427.   int check = 1 ;
  1428.   int loop_count_ops = nRecords ;
  1429.   int readValue[MAXATTR] = {0};
  1430.   NdbConnection     *MyTransaction = NULL ;
  1431.   NdbOperation      *MyOperation = NULL ;
  1432.   TTYPE ret_val = NO_FAIL ;
  1433.   
  1434.   ndbout << "Deleting records ..."<< endl << endl;
  1435.  
  1436.   for (int count=0 ; count < loop_count_ops ; count++)    {
  1438.     MyTransaction = pMyNdb->startTransaction();
  1439.     if (!MyTransaction) error_handler(pMyNdb->getNdbError(), NO_FAIL) ;
  1440.     
  1441.     MyOperation = MyTransaction->getNdbOperation(tableName);
  1442.     if (!MyOperation) error_handler(pMyNdb->getNdbError(), NO_FAIL) ;
  1444.     check = MyOperation->interpretedDeleteTuple();
  1445.     if( check == -1 ) error_handler(MyTransaction->getNdbError(), NO_FAIL) ;
  1447.     check = MyOperation->equal( attrName[0], (char*)&pkValue[count] );
  1448.     if( check == -1 ) error_handler(MyTransaction->getNdbError(), NO_FAIL) ;
  1450.       switch(tupleTest) {
  1451.       case 1:
  1452.         ret_val = t_exitMethods(count+1, MyOperation,  opType);
  1453.         break;
  1454.       case 2:
  1455.         ret_val = t_incValue(count+1, MyOperation);
  1456.         break;
  1457.       case 3:
  1458.         ret_val = t_subValue(count+1, MyOperation);
  1459.         break;
  1460.       case 4:
  1461.         ret_val = t_readAttr(count+1, MyOperation);
  1462.         break;
  1463.       case 5:
  1464.         ret_val = t_writeAttr(count+1, MyOperation);
  1465.         break;
  1466.       case 6:
  1467.         ret_val = t_loadConst(count+1, MyOperation, opType);
  1468.         break;
  1469.       case 7:
  1470.         ret_val = t_branch(count+1, MyOperation);
  1471.         break;
  1472.       case 8:
  1473.         ret_val = t_branchIfNull(count+1, MyOperation);
  1474.         break;
  1475.       case 9:
  1476.         ret_val = t_addReg(count+1, MyOperation);
  1477.         break;
  1478.       case 10:
  1479.         ret_val = t_subReg(count+1, MyOperation);
  1480.         break;
  1481.       case 11:
  1482.         ret_val = t_subroutineWithBranchLabel(count+1, MyOperation);
  1483.         break;
  1484.       default:
  1485.         break ;
  1486.       }
  1488.       if(11 != tupleTest)MyOperation->getValue(attrName[1], (char*)&readValue) ;
  1490.       if (MyTransaction->execute( Commit ) == -1 ) {
  1491.          error_handler(MyTransaction->getNdbError(), ret_val);
  1492.       } else if (NO_FAIL == ret_val /*|| UNDEF == ret_val*/ ) {
  1493.         ndbout << "OK" << endl;
  1494.       } else {
  1495.         bTestPassed = -1;
  1496.         ndbout << "Test passed when expected to fail" << endl;
  1497.       }//if
  1498.       ndbout << endl;
  1499.       pMyNdb->closeTransaction(MyTransaction);
  1500.    }
  1502.    ndbout << "Finished deleting records" << endl;
  1503.    return;
  1505. };
  1508. inline void setAttrNames(){
  1509.   for (int i = 0; i < MAXATTR; i++){
  1510.       BaseString::snprintf(attrName[i], MAXSTRLEN, "COL%d", i);
  1511.     }
  1512. }
  1515. inline void setTableNames(){
  1516.   BaseString::snprintf(tableName, MAXSTRLEN, "TAB1");
  1517. }