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

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

MySQL数据库

开发平台：

Visual C++

SQL99_test.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. // ODBC.cpp : Defines the entry point for the console application.
  18. //
  20. #include "SQL99_test.h"
  21. #include <iostream> // Loose later
  23. using namespace std; //
  25. #define MAXCOL 64
  26. #define DEFCOL 4
  28. #define MAXROW 64
  29. #define DEFROW 8
  31. #define MAXTHREADS 24
  32. #define DEFTHREADS 2
  34. #define MAXTABLES 16
  35. #define DEFTABLES 2
  37. #define MAXLOOPS 100000
  38. #define DEFLOOPS 4
  40. #define UPDATE_VALUE 7
  42. #define PKSIZE 2
  45. static int nNoOfThreads = 1 ;
  46. static int nNoOfCol = 4 ;
  47. static int nNoOfRows = 2 ;
  48. static int nNoOfLoops = 0 ;
  49. static int nNoOfTables = 2 ;
  50. static int nAPI = 0 ;
  51. static int tAttributeSize = sizeof(char) ;
  52. static attr_type AttributeType = T_CHAR ;
  53. static int nAggregate = 0 ;
  54. static int nArithmetic = 0 ;
  55. static int nPrint = 0 ;
  56. static int nColList = 0 ;
  57. static char szColNames[MAXCOL*MAX_COL_NAME] = { 0 } ;
  58. int createTables(char* szTableName, int nTables) ;
  61. /*************************************************
  62. Function: main - the entry point
  63. *************************************************/
  64. int main(int argc, char* argv[]){
  66. int nRetrunValue = NDBT_FAILED ;
  67. SQLRETURN rc = SQL_ERROR ;
  68. double dResultA = 0 ;
  69.     double dResultB = 0 ;
  70.     double dInput = 0 ;
  71.     int x = 0, y = 0 ;
  72.     int* pIntRefBuffer = NULL ;
  73.     float* pFloatRefBuffer = NULL ;
  74.     double* pDoubleRefBuffer = NULL ;
  75.     char* pCharRefBuffer = NULL ;
  76. char szColBuffer[MAX_COL_NAME] = { 0 } ;
  79.     ParseArguments(argc, (const char**)argv) ;
  81.     PARAMS* pparams = (PARAMS*)malloc(sizeof(PARAMS)*nNoOfThreads) ;
  82.     memset(pparams, 0, (sizeof(PARAMS)*nNoOfThreads)) ;
  84.     char* szTableNames = (char*)malloc(sizeof(char)*nNoOfTables*MAX_TABLE_NAME) ;
  85.     memset(szTableNames, 0, sizeof(char)*nNoOfTables*MAX_TABLE_NAME) ;
  87. UintPtr pThreadHandles[MAXTHREADS] = { NULL } ;
  89.     AssignTableNames(szTableNames, nNoOfTables) ;
  91. if(nAPI){
  92. if(0 != createTables(szTableNames, nNoOfTables)){
  93. printf("Failed to create tables through NDB API; quitting...n") ;
  94. NDBT_ProgramExit(NDBT_FAILED) ;
  95. return NDBT_FAILED ;
  96. }
  97. }else{
  99. //CreateDemoTables(szTableNames, nNoOfTables, DROP) ;
  100. rc = CreateDemoTables(szTableNames, nNoOfTables, CREATE) ;
  101. if(!(SQL_SUCCESS == rc || SQL_SUCCESS_WITH_INFO == rc)){
  102. printf("Failed to create tables, quiting now.n") ;
  103. NDBT_ProgramExit(NDBT_FAILED) ;
  104. return NDBT_FAILED ;
  105. }
  106. }
  108. // Store column names in the buffer for use in some stmts
  109. int k = 0 ;
  110. for(;;){
  111. memset((char*)szColBuffer, 0, strlen(szColBuffer)) ;
  112. sprintf((char*)szColBuffer, "COL%d", k) ;
  113.         strcat((char*)szColNames, (char*)szColBuffer) ;
  114.         ++k ;
  115. if( k == nNoOfCol ){
  116. break ;
  117. }
  118. strcat((char*)szColNames, ", ") ;
  119. } // for
  122.     switch(AttributeType){
  123.         case T_INT:
  124.             pIntRefBuffer = (int*)malloc(sizeof(int)*nNoOfRows*nNoOfCol*nNoOfThreads) ;
  125.             memset(pIntRefBuffer, 0, sizeof(int)*nNoOfRows*nNoOfCol*nNoOfThreads) ;
  126.             AssignRefNumValues(pIntRefBuffer, T_INT, nPrint) ;
  127.             StartThreads(pparams, (void*)pIntRefBuffer, nNoOfTables, szTableNames, AttributeType, pThreadHandles) ;
  128.             break ;
  129.         case T_FLOAT:
  130.             pFloatRefBuffer = (float*)malloc(sizeof(float)*nNoOfRows*nNoOfCol*nNoOfThreads) ;
  131.             memset(pFloatRefBuffer, 0, sizeof(float)*nNoOfRows*nNoOfCol*nNoOfThreads) ;
  132.             AssignRefNumValues(pFloatRefBuffer, T_FLOAT, nPrint) ;
  133.             StartThreads(pparams, (void*)pFloatRefBuffer, nNoOfTables, szTableNames, AttributeType, pThreadHandles) ;
  134.             break ;
  135. /*        case T_DOUBLE:
  136.             pDoubleRefBuffer = (double*)malloc(sizeof(double)*nNoOfRows*nNoOfCol*nNoOfThreads) ;
  137.             memset(pDoubleRefBuffer, 0, sizeof(double)*nNoOfRows*nNoOfCol*nNoOfThreads) ;
  138.             AssignRefNumValues(pDoubleRefBuffer, T_DOUBLE, 0) ;
  139.             StartThreads(pparams, (void*)pDoubleRefBuffer, nNoOfTables, szTableNames, AttributeType, pThreadHandles) ;
  140.             break ;
  141. */
  142.         case T_CHAR:
  143.             pCharRefBuffer = (char*)malloc(sizeof(char)*nNoOfRows*nNoOfCol*nNoOfThreads*MAX_CHAR_ATTR_LEN) ;
  144.             memset(pCharRefBuffer, 0, sizeof(char)*nNoOfRows*nNoOfCol*nNoOfThreads*MAX_CHAR_ATTR_LEN) ;
  145.             AssignRefCharValues(pCharRefBuffer, nPrint ) ;
  146.             StartThreads(pparams, (void*)pCharRefBuffer, nNoOfTables, szTableNames, AttributeType, pThreadHandles) ;
  147.             break ;
  148.         default:
  149.             break ;
  150.         }
  152. NdbThread_SetConcurrencyLevel(nNoOfThreads + 2) ;
  155. printf("nPerforming inserts...") ;
  156. SetThreadOperationType(pparams, T_INSERT) ;
  157. if(0 < WaitForThreads(pparams)){
  158. printf("tt%d thread(s) failedn") ;
  159. }else{
  160. printf("ttdonen") ;
  161. }
  162. printf("----------------------nn") ;
  163. PrintAll(szTableNames, nNoOfTables, AttributeType) ;
  165. printf("nVerifying inserts...") ;
  166. SetThreadOperationType(pparams, T_READ_VERIFY) ;
  167. if(0 < WaitForThreads(pparams)){
  168. printf("tt%d thread(s) failedn") ;
  169. }else{
  170. printf("ttdonen") ;
  171. }
  172. printf("----------------------nn") ;
  174. printf("nPerforming updates...") ;
  175. SetThreadOperationType(pparams, T_UPDATE) ;
  176. if(0 < WaitForThreads(pparams)){
  177. printf("tt%d thread(s) failedn") ;
  178. }else{
  179. printf("ttdonen") ;
  180. }
  181. printf("----------------------nn") ;
  182. //PrintAll(szTableNames, nNoOfTables, AttributeType) ;
  184. printf("nVerifying updates...") ;
  185. SetThreadOperationType(pparams, T_READ_VERIFY) ;
  186. if(0 < WaitForThreads(pparams)){
  187. printf("tt%d thread(s) failedn") ;
  188. }else{
  189. printf("ttdonen") ;
  190. }
  191. printf("----------------------nn") ;
  193. printf("nPerforming reads...") ;
  194. SetThreadOperationType(pparams, T_READ) ;
  195. if(0 < WaitForThreads(pparams)){
  196. printf("tt%d thread(s) failedn") ;
  197. }else{
  198. printf("ttdonen") ;
  199. }
  200. printf("----------------------nn") ;
  201. PrintAll(szTableNames, nNoOfTables, AttributeType) ;
  204. if(T_CHAR != AttributeType && nAggregate){
  205. printf("nTesting aggregate functions for each tablenn") ;
  206. printf("FNtCOLUMNtVALUEtttTOTAL ROWS WHEREntttttVALUE(S) > VALUEn--------------------------------------------------------nn") ;
  208. for(y = 0 ; y < nNoOfTables ; ++y){
  209. for(x = 0; x < nNoOfCol ; ++x){
  210. dResultA = dResultB = 0 ;
  211. AggregateFn(FN_MIN, (char*)(szTableNames + MAX_TABLE_NAME*y), x, NULL, &dResultA, AttributeType) ;
  212. AggregateFn(FN_COUNT, (char*)(szTableNames + MAX_TABLE_NAME*y) , x, &dResultA, &dResultB, AttributeType) ;
  213. ATTR_TYPE_SWITCH_AGR("MIN", x, dResultA, dResultB, AttributeType) ;
  214. }
  215. }
  217. for(y = 0; y < nNoOfTables ; ++y){ 
  218. for(x = 0; x < nNoOfCol ; ++x){
  219. dResultA = dResultB = 0 ;
  220. AggregateFn(FN_MAX, (char*)(szTableNames + MAX_TABLE_NAME*y), x, NULL, &dResultA, AttributeType) ;
  221. AggregateFn(FN_COUNT, (char*)(szTableNames + MAX_TABLE_NAME*y), x, &dResultA, &dResultB, AttributeType) ;
  222. ATTR_TYPE_SWITCH_AGR("MAX", x, dResultA, dResultB, AttributeType) ;
  223. }
  224. }
  226. for(y = 0 ; y < nNoOfTables ; ++y){
  227. for(x = 0; x < nNoOfCol ; ++x){
  228. dResultA = dResultB = 0 ;
  229. AggregateFn(FN_AVG, (char*)(szTableNames + MAX_TABLE_NAME*y), x, NULL, &dResultA, AttributeType) ;
  230. AggregateFn(FN_COUNT, (char*)(szTableNames + MAX_TABLE_NAME*y), x, &dResultA, &dResultB, AttributeType) ;
  231. ATTR_TYPE_SWITCH_AGR("AVG", x, dResultA, dResultB, AttributeType)
  232. }
  233. }
  235. printf("--------------------------------------------------------nn") ;
  236. }
  238. if(T_CHAR != AttributeType && nArithmetic){
  240. float nVal = (rand() % 10) /1.82342 ;
  242. for(int h = 0 ; h < nNoOfTables ; ++h){
  244. printf("nTesting arithmetic operatorsnfor each column in %s:n----------------------n", (char*)(szTableNames + MAX_TABLE_NAME*sizeof(char)*h) ) ;
  246. printf("nOperator [ * ]... tt") ;
  247. ArithOp((char*)(szTableNames + MAX_TABLE_NAME*sizeof(char)*h), nNoOfCol, &nVal, AttributeType, MULTI) ;
  248. printf("donen") ;
  250. printf("nOperator [ / ]... tt") ;
  251. ArithOp((char*)(szTableNames + MAX_TABLE_NAME*sizeof(char)*h), nNoOfCol, &nVal, AttributeType, DIVIDE) ;
  252. printf("donen") ;
  254. printf("nOperator [ + ]... tt") ;
  255. ArithOp((char*)(szTableNames + MAX_TABLE_NAME*sizeof(char)*h), nNoOfCol, &nVal, AttributeType, PLUS) ;
  256. printf("donen") ;
  258. printf("nOperator [ - ]... tt") ;
  259. ArithOp((char*)(szTableNames + MAX_TABLE_NAME*sizeof(char)*h), nNoOfCol, &nVal, AttributeType, MINUS) ;
  260. printf("donenn") ;
  261. /*
  262. printf("nOperator [ % ]... tt") ;
  263. ArithOp((char*)szTableNames, nNoOfCol, &nVal, AttributeType, MODULO) ;
  264. printf("donenn") ;
  265. */
  266. }
  267. }
  268. /*
  269. printf("nPerforming deletes...") ;
  270. SetThreadOperationType(pparams, T_DELETE) ;
  271. if(0 < WaitForThreads(pparams)){
  272. printf("tt%d thread(s) failedn") ;
  273. }else{
  274. printf("ttdonen") ;
  275. }
  276. printf("----------------------nn") ;
  278. printf("nVerifying deletes...") ;
  279. SetThreadOperationType(pparams, T_DELETE_VERIFY) ;
  280. if(0 < WaitForThreads(pparams)){
  281. printf("tt%d thread(s) failedn") ;
  282. }else{
  283. printf("ttdonen") ;
  284. }
  285. printf("----------------------nn") ;
  286. */
  287. StopThreads(pparams, pThreadHandles) ;
  289. //PrintAll(szTableNames, nNoOfTables, AttributeType) ;
  291. //CreateDemoTables(szTableNames, nNoOfTables, DROP) ;
  293. free((void*)szTableNames) ;
  294. free((void*)pparams) ;
  295. free((void*)pIntRefBuffer) ;
  296. free((void*)pFloatRefBuffer) ;
  297. free((void*)pDoubleRefBuffer) ;
  298. free((void*)pCharRefBuffer) ;
  300. return 0;
  301. }
  305. /**************************************************
  306. Function: ParseArguments
  307. ***************************************************/
  308. void ParseArguments(int argc, const char** argv){
  310.     int i = 1;
  312.     while (argc > 1){
  314.         if (strcmp(argv[i], "-t") == 0)
  315.             {
  316.             nNoOfThreads = atoi(argv[i+1]);
  317.             if ((nNoOfThreads < 1) || (nNoOfThreads > MAXTHREADS))
  318.                 nNoOfThreads = DEFTHREADS ;
  319.             }
  320.         else if (strcmp(argv[i], "-c") == 0)
  321.             {
  322.             nNoOfCol = atoi(argv[i+1]);
  323.             if ((nNoOfCol < 2) || (nNoOfCol > MAXCOL))
  324.                 nNoOfCol = DEFCOL ;
  325.             }
  326.         else if (strcmp(argv[i], "-l") == 0)
  327.             {
  328.             nNoOfLoops = atoi(argv[i+1]);
  329.             if ((nNoOfLoops < 0) || (nNoOfLoops > MAXLOOPS))
  330.                 nNoOfLoops = DEFLOOPS ;
  331.             }
  332.         else if (strcmp(argv[i], "-r") == 0)
  333.             {
  334.             nNoOfRows = atoi(argv[i+1]);;
  335.             if ((nNoOfRows < 0) || (nNoOfRows > MAXROW))
  336.                 nNoOfRows = DEFROW ;
  337.             }
  338. else if (strcmp(argv[i], "-m") == 0)
  339.             {
  340.             nArithmetic = 1 ;
  341. argc++ ;
  342. i-- ;
  343.             }
  344. else if (strcmp(argv[i], "-g") == 0)
  345.             {
  346.             nAggregate = 1 ;
  347. argc++ ;
  348. i-- ;
  349.             }
  350. else if (strcmp(argv[i], "-n") == 0)
  351.             {
  352. nAPI = 1 ;
  353. argc++ ;
  354. i-- ;
  355.             }
  356. else if (strcmp(argv[i], "-v") == 0)
  357.             {
  358. nPrint = 1 ;
  359. argc++ ;
  360. i-- ;
  361.             }
  362.         else if (strcmp(argv[i], "-a") == 0)
  363.             {
  364.             if(strcmp(argv[i+1], "int") == 0){
  365.                 AttributeType = T_INT ;
  366. tAttributeSize = 32 ;
  367.                 }else if(strcmp(argv[i+1], "float") == 0){
  368.                     AttributeType = T_FLOAT ;
  369. tAttributeSize = 64 ;
  370.                     }else if(strcmp(argv[i+1], "char") == 0){
  371.                         AttributeType = T_CHAR ;
  372.                         }
  373.             }
  374.         else
  375.             {
  376.             cout << "Arguments:n";
  377. cout << "-n Create tables using NDB API (vs ODBC by default)" << endl;
  378.             cout << "-t Number of threads; maximum 24, default 2n" << endl;
  379.             cout << "-c Number of columns per table; maximum 64, default 4n" << endl;
  380.             cout << "-r Number of rows; maximum 64, default 8n" << endl;
  381.             cout << "-a Type of attribute to use: int, double or char; default int " << endl;
  382.             cout << "-g Test aggregate functions" << endl;
  383. cout << "-m Test arithmetic operators" << endl;
  384. cout << "-v Print executed statements" << endl;
  385.             exit(-1);
  386.             }
  388.         argc -= 2 ;
  389.         i = i + 2 ;
  390.         }
  392. char *szAttrType[MAX_STR_LEN] = { 0 } ;
  393. switch(AttributeType){
  394.         case T_INT:
  395.             strcpy((char*)szAttrType, "Integer") ;
  396.             break ;
  397.         case T_FLOAT:
  398.             strcpy((char*)szAttrType, "Float") ;
  399.             break ;
  400. /*        case T_DOUBLE:
  401.             strcpy((char*)szAttrType, "Double") ;
  402.             break ;
  403. */
  404.         case T_CHAR:
  405.             strcpy((char*)szAttrType, "Character") ;
  406.             break ;
  407.         default:
  408.             strcpy((char*)szAttrType, "Not defined") ;
  409.             break ;
  410.     }
  413. printf("nnCurrent parameters: %d thread(s), %d tables, %d rows, %d colums, attribute type: %snn", nNoOfThreads, nNoOfTables, nNoOfRows, nNoOfCol, szAttrType) ;
  414.     }
  419. /*************************************************
  420. Function: ThreadFnInt - thread function
  421. for int attributes
  422. *************************************************/
  423. void* ThreadFnInt(void* pparams){
  425.     SQLRETURN retcode = SQL_ERROR ;
  426.     SQLCHAR szStmtBuffer[MAX_SQL_STMT] = { 0 } ;
  427.     SQLCHAR szValueBuffer[MAX_VALUE_LEN] = { 0 } ;
  428.     SQLCHAR szAuxBuffer[MAX_STR_LEN] = { 0 } ;
  429.     SQLCHAR szColBuffer[MAX_COL_NAME] = { 0 } ;
  430.     SQLINTEGER cbInt = 0 ;
  431.     ODBC_HANDLES stHandles ;
  432.     memset(&stHandles, 0, sizeof(ODBC_HANDLES)) ;
  434.     int r = 0, j = 0 ;
  435.     //Get thread parameters 
  436.     PARAMS* p = (PARAMS*)pparams ;
  437.     int* pRef = (int*)p->pThreadRef ;
  439.     int* pBindBuffer = (int*)malloc(sizeof(int)*nNoOfCol) ;
  441.     //printf("Thread #%dn", p->nThreadID) ;
  443.     retcode = GetHandles(&stHandles, GET, 0) ;
  445. if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode ) {
  446. p->report_status = S_STARTED ;
  447. }else{
  448. printf("Thread #%d failed to allocate handles, exiting now.n", p->nThreadID) ;
  449. free((void*)pBindBuffer) ;
  450. p->nError = 1 ;
  451. p->report_status = S_EXIT ;
  452. return 0 ;
  453. }
  454.     
  455. //p->report_status = S_STARTED ;
  457.     //Main thread loop
  458.     for(;;){
  460.         while(S_IDLE == p->thread_status){
  461.             NdbSleep_MilliSleep(1) ;
  462.             }
  464.     if(S_STOP == p->thread_status) {
  465.         break ;
  466.         }else{
  467.             p->thread_status = S_BUSY ;
  468.             }
  470.     switch(p->op_type){
  473.         /************************************** T_INSERT case **************************************/
  474.         case T_INSERT:
  476.             for(r = 0 ; r < nNoOfRows ; ++r){
  478. if(!nColList){
  479. sprintf((char*)szStmtBuffer, "INSERT INTO %s VALUES(", p->szTableName) ; 
  480. }else{
  481. sprintf((char*)szStmtBuffer, "INSERT INTO %s (%s) VALUES(", p->szTableName, szColNames) ;
  482. }
  484.                 //sprintf((char*)szStmtBuffer, "INSERT INTO %s VALUES(", p->szTableName) ; 
  486.                 for(j = 0 ;;){
  487.                     sprintf((char*)szValueBuffer,"%d", pRef[nNoOfCol*r + j]) ;
  488.                     strncat((char*)szStmtBuffer, (char*)szValueBuffer, strlen((char*)szValueBuffer)) ;
  489.                     ++j ;
  490.                     if(nNoOfCol == j) break ;
  491.                     strcat((char*)szStmtBuffer, ", ") ;
  492.                     }
  493.             strcat((char*)szStmtBuffer, ")") ;
  494. if(nPrint) printf("n> %sn", szStmtBuffer) ;
  495.             retcode = SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS) ;
  496. if(SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
  497. }else{
  498. p->nError = 1 ;
  499. printf("INSERT in thread #%d failedn", p->nThreadID) ;
  500. HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
  501. }
  502. }
  503.         break ;
  506.         /************************************** T_READ case **************************************/
  507.         case T_READ:
  509.             for(r = 0 ; r < nNoOfRows ; r++){
  511.                 sprintf((char*)szStmtBuffer, "SELECT * FROM %s WHERE COL0 = %d", p->szTableName, pRef[nNoOfCol*r]) ;
  512. if(nPrint) printf("n> %sn", szStmtBuffer) ;
  513.                 ODBC_FN(SQLExecDirect(stHandles.hstmt, (SQLCHAR*)szStmtBuffer, SQL_NTS), retcode) ;
  515.                 for(j = 0 ; j < nNoOfCol ; ++j){
  516.                     ODBC_FN(SQLBindCol(stHandles.hstmt, (j+1), SQL_C_SLONG, (void*)&pBindBuffer[j], sizeof(SQLINTEGER), &cbInt), retcode) ;
  517.                     }
  519.             for (;;) {
  520.                 retcode = SQLFetch(stHandles.hstmt);
  522.                 if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
  523.                     for(int k = 0 ; k < nNoOfCol ; ++k){
  524.                         if(p->nVerifyFlag){
  525.                             if(pBindBuffer[k] != pRef[nNoOfCol*r + k])
  526.                                 printf("Expected: %d Actual: %dn", pBindBuffer[k], pRef[nNoOfCol*r + k]) ;
  527.                             }
  528.                         }
  529.                     }else if(SQL_NO_DATA == retcode){
  530.                         break ;
  531.                         }else{
  532. p->nError = 1 ;
  533. printf("READ in thread #%d failedn", p->nThreadID) ;
  534.                             HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
  535.                             }
  536.                     //printf("n") ;
  537.                 }
  538. SQLCloseCursor(stHandles.hstmt) ;
  539. }
  540.         break ;
  543.         /************************************** T_UPDATE case **************************************/
  544.         case T_UPDATE:
  545.             for(r = 0 ; r < nNoOfRows ; ++r){
  547.                 sprintf((char*)szStmtBuffer, "UPDATE %s SET ", p->szTableName) ; 
  548.                 for(j = 1 ;;){
  549.                     pRef[nNoOfCol*r + j] = pRef[nNoOfCol*r + j] + UPDATE_VALUE ;
  550.                     sprintf((char*)szColBuffer,"COL%d = %d",  j, pRef[nNoOfCol*r + j]) ;
  551.                     strncat((char*)szStmtBuffer, (char*)szColBuffer, strlen((char*)szColBuffer)) ;
  552.                     ++j ;
  553.                     if(nNoOfCol == j) break ;
  554.                     strcat((char*)szStmtBuffer, ", ") ;
  555. }
  556. sprintf((char*)szAuxBuffer, " WHERE COL0 = %d ;", pRef[nNoOfCol*r]) ;
  557. strcat((char*)szStmtBuffer, (char*)szAuxBuffer);
  558. if(nPrint) printf("n> %sn", szStmtBuffer) ;
  559. retcode = SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS) ;
  561. if(SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
  562. }else{
  563. p->nError = 1 ;
  564. printf("UPDATE in thread %d failedn", p->nThreadID) ;
  565. HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
  566. }
  567. }
  568.         break ;
  571.         /************************************** T_DELETE case **************************************/
  572.         case T_DELETE:
  573.             for(r = 0 ; r < nNoOfRows ; ++r){
  574.                 sprintf((char*)szStmtBuffer, "DELETE * FROM %s WHERE COL0 = %d", p->szTableName, pRef[nNoOfCol*r]) ;
  575.                 if(nPrint) printf("n> %sn", szStmtBuffer) ;
  576. retcode = SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS) ;
  577. if(SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
  578. }else if( 1 == p->nVerifyFlag  && SQL_NO_DATA != retcode){
  579. p->nError = 1 ;
  580. printf("nVerification failed: the row foundn") ;
  581.                 }else{
  582. p->nError = 1 ;
  583. printf("INSERT in thread %d failedn", p->nThreadID) ;
  584. HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
  585. }
  587. }
  588.         break ;
  591.         /************************************** default case **************************************/
  592.         default:
  593.             break ;
  594.         }//switch
  595. p->thread_status = S_IDLE ;
  596.         } //for
  598. free((void*)pBindBuffer) ;
  599. GetHandles(&stHandles, FREE, 0) ;
  600. p->thread_status = S_EXIT ;
  601. return 0 ;
  602.     };
  606. /*************************************************
  607. Function: ThreadFnFloat - thread function
  608. for float attributes
  609. *************************************************/
  610. void* ThreadFnFloat(void* pparams){
  612.     SQLRETURN retcode = SQL_ERROR ;
  613.     SQLCHAR szStmtBuffer[MAX_SQL_STMT] = { 0 } ;
  614.     SQLCHAR szValueBuffer[MAX_VALUE_LEN] = { 0 } ;
  615.     SQLCHAR szAuxBuffer[MAX_STR_LEN] = { 0 } ;
  616.     SQLCHAR szColBuffer[MAX_COL_NAME] = { 0 } ;
  617.     SQLINTEGER cbFloat = 0 ;
  618.     ODBC_HANDLES stHandles ;
  619.     memset(&stHandles, 0, sizeof(ODBC_HANDLES)) ;
  621.     int r = 0, j = 0 ;
  622.     //Get thread parameters 
  623.     PARAMS* p = (PARAMS*)pparams ;
  625.     float* pRef = (float*)p->pThreadRef ;
  626.     float* pBindBuffer = (float*)malloc(sizeof(float)*nNoOfCol) ;
  628.     //printf("Thread #%dn", p->nThreadID) ;
  630.     retcode = GetHandles(&stHandles, GET, 0) ;
  632. if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode ) {
  633. p->report_status = S_STARTED ;
  634. }else{
  635. printf("Thread #%d failed to allocate handles, exiting now.n", p->nThreadID) ;
  636. free((void*)pBindBuffer) ;
  637. p->nError = 1 ;
  638. p->report_status = S_EXIT ;
  639. return 0 ;
  640. }
  642.     //p->report_status = S_STARTED ;
  644.     //Main thread loop
  645.     for(;;){
  647.         while(S_IDLE == p->thread_status){
  648.             NdbSleep_MilliSleep(1) ;
  649.             }
  651.     if(S_STOP == p->thread_status) {
  652.         break ;
  653.         }else{
  654.             p->thread_status = S_BUSY ;
  655.             }
  657.     switch(p->op_type){
  660.         /************************************** T_INSERT case **************************************/
  661.         case T_INSERT:
  663.             for(r = 0 ; r < nNoOfRows ; ++r){
  665. if(!nColList){
  666. sprintf((char*)szStmtBuffer, "INSERT INTO %s VALUES(", p->szTableName) ; 
  667. }else{
  668. sprintf((char*)szStmtBuffer, "INSERT INTO %s (%s) VALUES(", p->szTableName, szColNames) ;
  669. }
  671.                 //sprintf((char*)szStmtBuffer, "INSERT INTO %s VALUES(", p->szTableName) ; 
  673.                 for(j = 0 ;;){
  674.                     sprintf((char*)szValueBuffer,"%f", pRef[nNoOfCol*r + j]) ;
  675.                     strncat((char*)szStmtBuffer, (char*)szValueBuffer, strlen((const char*)szValueBuffer)) ;
  676.                     ++j ;
  677.                     if(nNoOfCol == j) break ;
  678.                     strcat((char*)szStmtBuffer, ", ") ;
  679.                     }
  680.             strcat((char*)szStmtBuffer, ")") ;
  681. if(nPrint) printf("n> %sn", szStmtBuffer) ;
  682.             retcode = SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS) ;
  683. if(SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
  684. }else{
  685. p->nError = 1 ;
  686. printf("INSERT in thread #%d failedn", p->nThreadID) ;
  687. HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
  688. }
  689.                 }
  690.         break ;
  693.         /************************************** T_READ case **************************************/
  694.         case T_READ:
  696.             for(r = 0 ; r < nNoOfRows ; ++r){
  698.                 sprintf((char*)szStmtBuffer, "SELECT * FROM %s WHERE COL0 = %f", p->szTableName, pRef[nNoOfCol*r]) ;
  699. if(nPrint) printf("n> %sn", szStmtBuffer) ;
  700.                 ODBC_FN(SQLExecDirect(stHandles.hstmt, (SQLCHAR*)szStmtBuffer, SQL_NTS), retcode) ;
  702.                 for(j = 0 ; j < nNoOfCol ; ++j){
  703.                     ODBC_FN(SQLBindCol(stHandles.hstmt, (j+1), SQL_C_FLOAT, (void*)&pBindBuffer[j], sizeof(SQLFLOAT), &cbFloat), retcode) ;
  704.                     }
  706.             for (;;) {
  707.                 retcode = SQLFetch(stHandles.hstmt);
  709.                 if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
  710.                     for(int k = 0 ; k < nNoOfCol ; ++k){
  711.                         if(p->nVerifyFlag){
  712.                             if(abs(pBindBuffer[k] - pRef[nNoOfCol*r + k]) > FLTDEV )
  713.                                 printf("Expected: %f Actual: %fn", pBindBuffer[k], pRef[nNoOfCol*r + k]) ;
  714.                             }
  715.                         }
  716.                     }else if(SQL_NO_DATA == retcode){
  717.                         break ;
  718. }else{
  719. p->nError = 1 ;
  720. printf("READ in thread #%d failedn", p->nThreadID) ;
  721. HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
  722. }
  723.                     //printf("n") ;
  724.                 }
  725.         SQLCloseCursor(stHandles.hstmt) ;
  726.                 }
  727.         break ;
  730.         /************************************** T_UPDATE case **************************************/
  731.         case T_UPDATE:
  732.             for(r = 0 ; r < nNoOfRows ; ++r){
  734.                 sprintf((char*)szStmtBuffer, "UPDATE %s SET ", p->szTableName) ; 
  735.                 for(j = 1 ;;){
  736.                     pRef[nNoOfCol*r + j] = pRef[nNoOfCol*r + j] + UPDATE_VALUE ;
  737.                     sprintf((char*)szColBuffer,"COL%d = %f",  j, pRef[nNoOfCol*r + j]) ;
  738.                     strncat((char*)szStmtBuffer, (char*)szColBuffer, strlen((char*)szColBuffer)) ;
  739.                     ++j ;
  740.                     if(nNoOfCol == j) break ;
  741.                     strcat((char*)szStmtBuffer, ", ") ;
  742.                     }
  743.             sprintf((char*)szAuxBuffer, " WHERE COL0 = %f ;", pRef[nNoOfCol*r]) ;
  744.             strcat((char*)szStmtBuffer, (char*)szAuxBuffer);
  745. if(nPrint) printf("n> %sn", szStmtBuffer) ;
  746. retcode = SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS) ;
  747. if(SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
  748. }else{
  749. p->nError = 1 ;
  750. printf("UPDATE in thread #%d failedn", p->nThreadID) ;
  751. HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
  752. }
  753. }
  754.         break ;
  757.         /************************************** T_DELETE case **************************************/
  758.         case T_DELETE:
  759.             for(r = 0 ; r < nNoOfRows ; ++r){
  760.                 sprintf((char*)szStmtBuffer, "DELETE * FROM %s WHERE COL0 = %f", p->szTableName, pRef[nNoOfCol*r]) ;
  761.                 if(nPrint) printf("n> %sn", szStmtBuffer) ;
  762. retcode = SQLExecDirect(stHandles.hstmt, (SQLCHAR*)szStmtBuffer, SQL_NTS) ;
  763. if(SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
  764. }else if( 1 == p->nVerifyFlag && SQL_NO_DATA != retcode){
  765. p->nError = 1 ;
  766.                     printf("nVerification failed: still row existsn") ;
  767. }else{
  768. p->nError = 1 ;
  769. printf("DELETE in thread #%d failedn", p->nThreadID) ;
  770. HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
  771. }
  772. }
  773.         break ;
  776.         /************************************** default case **************************************/
  777.         default:
  778.             break ;
  779.         }//switch
  780. p->thread_status = S_IDLE ;
  781.         } //for
  783. free((void*)pBindBuffer) ;
  784. GetHandles(&stHandles, FREE, 0) ;
  785. p->thread_status = S_EXIT ;
  786. return 0 ;
  787.     };
  791. /*************************************************
  792. Function: ThreadFnDouble - thread function
  793. for double attributes
  794. *************************************************/
  795. /*
  796. void* ThreadFnDouble(void* pparams){
  798.     SQLRETURN retcode = SQL_ERROR ;
  799.     SQLCHAR szStmtBuffer[MAX_SQL_STMT] = { 0 } ;
  800.     SQLCHAR szValueBuffer[MAX_VALUE_LEN] = { 0 } ;
  801.     SQLCHAR szAuxBuffer[MAX_STR_LEN] = { 0 } ;
  802.     SQLCHAR szColBuffer[MAX_COL_NAME] = { 0 } ;
  803.     SQLINTEGER cbDouble = 0 ;
  804.     ODBC_HANDLES stHandles ;
  805.     memset(&stHandles, 0, sizeof(ODBC_HANDLES)) ;
  806.     int r = 0, j = 0 ;
  808.     //Get thread parameters 
  809.     PARAMS* p = (PARAMS*)pparams ;
  810.     double* pRef = (double*)p->pThreadRef ;
  812.     double* pBindBuffer = (double*)malloc(sizeof(double)*nNoOfCol) ;
  814.     //printf("Thread #%dn", p->nThreadID) ;
  816.     retcode = GetHandles(&stHandles, GET, 0) ;
  818. if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode ) {
  819. p->report_status = S_STARTED ;
  820. }else{
  821. printf("Thread #%d failed to allocate handles, exiting now.n", p->nThreadID) ;
  822. free((void*)pBindBuffer) ;
  823. p->report_status = S_EXIT ;
  824. return 0 ;
  825. }
  826.     //p->report_status = S_STARTED ;
  828.     //Main thread loop
  829.     for(;;){
  831.         while(S_IDLE == p->thread_status){
  832.             NdbSleep_MilliSleep(1) ;
  833.             }
  835.     if(S_STOP == p->thread_status) {
  836.         break ;
  837.         }else{
  838.             p->thread_status = S_BUSY ;
  839.             }
  841.     switch(p->op_type){
  844.   /************************************** T_INSERT case **************************************/
  845.   /*     case T_INSERT:
  847.             for(r = 0 ; r < nNoOfRows ; ++r){
  848.                 sprintf((char*)szStmtBuffer, "INSERT INTO %s VALUES(", p->szTableName) ; 
  849.                 for(j = 0 ;;){
  850.                     sprintf((char*)szValueBuffer,"%.9f", pRef[nNoOfCol*r + j]) ;
  851.                     strncat((char*)szStmtBuffer, (char*)szValueBuffer, strlen((const char*)szValueBuffer)) ;
  852.                     ++j ;
  853.                     if(nNoOfCol == j) break ;
  854.                     strcat((char*)szStmtBuffer, ", ") ;
  855.                     }
  856.             strcat((char*)szStmtBuffer, ")") ;
  857.             ODBC_FN(SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS), retcode) ;
  858.                 }
  860.         break ;
  863.   /************************************** T_READ case **************************************/
  864.   /*      case T_READ:
  866.             for(r = 0 ; r < nNoOfRows ; ++r){
  867.                 sprintf((char*)szStmtBuffer, "SELECT * FROM %s WHERE COL0 = %.9f", p->szTableName, pRef[nNoOfCol*r]) ;
  868.                 ODBC_FN(SQLExecDirect(stHandles.hstmt, (SQLCHAR*)szStmtBuffer, SQL_NTS), retcode) ;
  869.                 for(j = 0 ; j < nNoOfCol ; ++j){
  870.                     ODBC_FN(SQLBindCol(stHandles.hstmt, (j+1), SQL_C_DOUBLE, (void*)&pBindBuffer[j], sizeof(SQLDOUBLE), &cbDouble), retcode) ;
  871.                     }
  872.             for (;;) {
  873.                 retcode = SQLFetch(stHandles.hstmt);
  875.                 if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
  876.                     for(int k = 0 ; k < nNoOfCol ; ++k){
  877.                         if(p->nVerifyFlag){
  878.                             if(abs(pBindBuffer[k] - pRef[nNoOfCol*r + k]) > DBLDEV)
  879.                                 printf("Expected: %.9f Actual: %.9fn", pBindBuffer[k], pRef[nNoOfCol*r + k]) ;
  880.                             }
  881.                         }
  882.                     }else if(SQL_NO_DATA == retcode){
  883.                         break ;
  884.                         }else{
  885.                             HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
  886.                             }
  887.                     //printf("n") ;
  888.                 }
  889.         SQLCloseCursor(stHandles.hstmt) ;
  890.                 }
  891.         break ;
  894.     /************************************** T_UPDATE case **************************************/
  895.     /*    case T_UPDATE:
  896.             for(r = 0 ; r < nNoOfRows ; ++r){
  898.                 sprintf((char*)szStmtBuffer, "UPDATE %s SET ", p->szTableName) ; 
  899.                 for(j = 1 ;;){
  900.                     pRef[nNoOfCol*r + j] = pRef[nNoOfCol*r + j] + UPDATE_VALUE ;
  901.                     sprintf((char*)szColBuffer,"COL%d = %.9f",  j, pRef[nNoOfCol*r + j]) ;
  902.                     strncat((char*)szStmtBuffer, (char*)szColBuffer, strlen((char*)szColBuffer)) ;
  903.                     ++j ;
  904.                     if(nNoOfCol == j) break ;
  905.                     strcat((char*)szStmtBuffer, ", ") ;
  906.                     }
  907.             sprintf((char*)szAuxBuffer, " WHERE COL0 = %.9f ;", pRef[nNoOfCol*r]) ;
  908.             strcat((char*)szStmtBuffer, (char*)szAuxBuffer);
  909.             ODBC_FN(SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS), retcode) ;
  910.                 }
  911.         break ;
  914.   /************************************** T_DELETE case **************************************/
  915.   /*      case T_DELETE:
  916.             for(r = 0 ; r < nNoOfRows ; ++r){
  917.                 sprintf((char*)szStmtBuffer, "DELETE FROM %s WHERE COL0 = %.9f", p->szTableName, pRef[nNoOfCol*r]) ;
  918.                 retcode = SQLExecDirect(stHandles.hstmt, (SQLCHAR*)szStmtBuffer, SQL_NTS) ;
  919.                 if( 1 == p->nVerifyFlag && SQL_NO_DATA != retcode ){
  920.                     printf("nVerification failed: still row existsn") ;
  921.                     }
  922.                 }
  923.         break ;
  926.     /************************************** default case **************************************/
  927.     /*    default:
  928.             break ;
  929.         }//switch
  930. p->thread_status = S_IDLE ;
  931.         } //for
  933. free((void*)pBindBuffer) ;
  934. GetHandles(&stHandles, FREE, 0) ;
  935. p->thread_status = S_EXIT ;
  936. return 0 ;
  937.     };
  941. /*************************************************
  942. Function: ThreadFnChar - thread function
  943. for character attributes
  944. *************************************************/
  945. void* ThreadFnChar(void* pparams){
  947.     SQLRETURN retcode = SQL_ERROR ;
  948.     SQLCHAR szStmtBuffer[MAX_SQL_STMT] = { 0 } ;
  949.     SQLCHAR szValueBuffer[MAX_VALUE_LEN] = { 0 } ;
  950.     SQLCHAR szAuxBuffer[MAX_STR_LEN] = { 0 } ;
  951.     SQLCHAR szColBuffer[MAX_COL_NAME] = { 0 } ;
  952.     SQLINTEGER cbChar = 0 ;
  953.     ODBC_HANDLES stHandles ;
  954.     memset(&stHandles, 0, sizeof(ODBC_HANDLES)) ;
  955.     int r = 0, j = 0 ;
  957.     //Get thread parameters 
  958.     PARAMS* p = (PARAMS*)pparams ;
  959.     char* pRef = (char*)p->pThreadRef ;
  960.     char* pBindBuffer = (char*)malloc(sizeof(char)*nNoOfCol*MAX_CHAR_ATTR_LEN) ;
  962.     //printf("Thread #%dn", p->nThreadID) ;
  964.     retcode = GetHandles(&stHandles, GET, 0) ;
  966. if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode ) {
  967. p->report_status = S_STARTED ;
  968. }else{
  969. printf("Thread #%d failed to allocate handles, retcode = %d, exiting now.n", p->nThreadID, retcode) ;
  970. p->nError = 1 ;
  971. free((void*)pBindBuffer) ;
  972. p->report_status = S_EXIT ;
  973. return 0 ;
  974. }
  976.     //Main thread loop
  977.     for(;;){
  979. while(S_IDLE == p->thread_status){
  980.             NdbSleep_MilliSleep(1) ;
  981. }
  983. if(S_STOP == p->thread_status) {
  984. break ;
  985.         }else{
  986.             p->thread_status = S_BUSY ;
  987. }
  989. switch(p->op_type){
  992.         /************************************** T_INSERT case **************************************/
  993.         case T_INSERT:
  995.             for(r = 0 ; r < nNoOfRows ; ++r){
  996.                 memset(szStmtBuffer, 0, strlen(szStmtBuffer)) ;
  997. if(!nColList){
  998. sprintf((char*)szStmtBuffer, "INSERT INTO %s VALUES(", p->szTableName) ; 
  999. }else{
  1000. sprintf((char*)szStmtBuffer, "INSERT INTO %s (%s) VALUES(", p->szTableName, szColNames) ;
  1001. }
  1003.                 for(j = 0 ;;){
  1004.                     sprintf((char*)szValueBuffer,"'%s'", (char*)(pRef + nNoOfCol*r*MAX_CHAR_ATTR_LEN*sizeof(char) + j*MAX_CHAR_ATTR_LEN*sizeof(char))) ;
  1005.                     strncat((char*)szStmtBuffer, (char*)szValueBuffer, strlen((const char*)szValueBuffer)) ;
  1006.                     ++j ;
  1007.                     if(nNoOfCol == j) break ;
  1008.                     strcat((char*)szStmtBuffer, ", ") ;
  1009.                     }
  1010.             strcat((char*)szStmtBuffer, ")") ;
  1012. if(nPrint) printf("n> %sn", szStmtBuffer) ;
  1013. retcode = SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS) ;
  1014. if(SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
  1015. }else{
  1016. p->nError = 1 ;
  1017. printf("INSERT in thread #%d failedn", p->nThreadID) ;
  1018. HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
  1019. }
  1020. }
  1022.         break ;
  1025.         /************************************** T_READ case **************************************/
  1026.         case T_READ:
  1028.             for(r = 0 ; r < nNoOfRows ; ++r){
  1029.                 sprintf((char*)szStmtBuffer, "SELECT * FROM %s WHERE COL0 = '%s'", p->szTableName, (char*)(pRef + nNoOfCol*r*MAX_CHAR_ATTR_LEN*sizeof(char))) ;
  1030.         if(nPrint) printf("n> %sn", szStmtBuffer) ;
  1031. ODBC_FN(SQLExecDirect(stHandles.hstmt, (SQLCHAR*)szStmtBuffer, SQL_NTS), retcode) ;
  1032.                 for(j = 0 ; j < nNoOfCol ; ++j){
  1033.                     ODBC_FN(SQLBindCol(stHandles.hstmt, (j+1), SQL_C_CHAR, (void*)(pBindBuffer+j*MAX_CHAR_ATTR_LEN*sizeof(char)), MAX_CHAR_ATTR_LEN, &cbChar), retcode) ;
  1034.                     }
  1035.             for (;;) {
  1036. retcode = SQLFetch(stHandles.hstmt);
  1038.                 if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
  1039. for(int k = 0 ; k < nNoOfCol ; ++k){
  1040. if(p->nVerifyFlag){
  1041.                             if(!strcmp((char*)(pBindBuffer + k*MAX_CHAR_ATTR_LEN*sizeof(char)), (char*)(pRef + nNoOfCol*r*MAX_CHAR_ATTR_LEN*sizeof(char) + k*MAX_CHAR_ATTR_LEN*sizeof(char))))
  1042.                                 printf("Expected: %s Actual: %sn", (char*)(pBindBuffer + k*MAX_CHAR_ATTR_LEN*sizeof(char)), (char*)(pRef + nNoOfCol*r*MAX_CHAR_ATTR_LEN*sizeof(char) + k*MAX_CHAR_ATTR_LEN*sizeof(char))) ;
  1043.                             }
  1044. }
  1045. }else if(SQL_NO_DATA == retcode){
  1046. break ;
  1047. }else{
  1048. p->nError = 1 ;
  1049. printf("READ in thread #%d failedn", p->nThreadID) ;
  1050. HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
  1051. }
  1052.                     //printf("n") ;
  1053. }
  1054. SQLCloseCursor(stHandles.hstmt) ;
  1055. }
  1056.         break ;
  1059.         /************************************** T_UPDATE case **************************************/
  1060.         case T_UPDATE:
  1061.             for(r = 0 ; r < nNoOfRows ; ++r){
  1062.                 sprintf((char*)szStmtBuffer, "UPDATE %s SET ", p->szTableName) ; 
  1063.                 for(j = 1 ;;){
  1064.                     swab((char*)(pRef + nNoOfCol*r*MAX_CHAR_ATTR_LEN*sizeof(char) + j*MAX_CHAR_ATTR_LEN*sizeof(char)), (char*)szColBuffer, MAX_CHAR_ATTR_LEN*sizeof(char)) ;
  1065.                     memcpy((void*)(pRef + nNoOfCol*r*MAX_CHAR_ATTR_LEN*sizeof(char) + j*MAX_CHAR_ATTR_LEN*sizeof(char)), (void*)szColBuffer, MAX_CHAR_ATTR_LEN*sizeof(char)) ;
  1066.                     sprintf((char*)szColBuffer,"COL%d = '%s'",  j, (char*)(pRef + nNoOfCol*r*MAX_CHAR_ATTR_LEN*sizeof(char) + j*MAX_CHAR_ATTR_LEN*sizeof(char))) ;
  1067.                     strncat((char*)szStmtBuffer, (char*)szColBuffer, strlen((char*)szColBuffer)) ;
  1068.                     ++j ;
  1069.                     if(nNoOfCol == j) break ;
  1070.                     strcat((char*)szStmtBuffer, ", ") ;
  1071.                     }
  1072.             sprintf( (char*)szAuxBuffer, " WHERE COL0 = '%s';", (char*)(pRef + nNoOfCol*r*MAX_CHAR_ATTR_LEN*sizeof(char)) ) ;
  1073.             strcat((char*)szStmtBuffer, (char*)szAuxBuffer) ;
  1074. if(nPrint) printf("n> %sn", szStmtBuffer) ;
  1075.             retcode = SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS) ;
  1076. if(SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
  1077. }else{
  1078. p->nError = 1 ;
  1079. printf("UPDATE in thread #%d failedn", p->nThreadID) ;
  1080. HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
  1081. }
  1082. }
  1083.         break ;
  1086.         /************************************** T_DELETE case **************************************/
  1087.         case T_DELETE:
  1088.             for(r = 0 ; r < nNoOfRows ; ++r){
  1089.                 sprintf((char*)szStmtBuffer, "DELETE FROM %s WHERE COL0 = '%s'", p->szTableName, (char*)(pRef + nNoOfCol*r*MAX_CHAR_ATTR_LEN*sizeof(char))) ;
  1090.              if(nPrint) printf("n> %sn", szStmtBuffer) ;
  1091. retcode = SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS) ;
  1092. if(SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
  1093. }else if(1 == p->nVerifyFlag && SQL_NO_DATA != retcode){
  1094.                     p->nError = 1 ;
  1095. printf("nVerification failed: still row existsn") ;
  1096. }else{
  1097. p->nError = 1 ;
  1098. printf("INSERT in thread #%d failedn", p->nThreadID) ;
  1099. HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
  1100.                 }
  1101. }
  1102.         break ;
  1105.         /************************************** default case **************************************/
  1106.         default:
  1107.             break ;
  1108. }//switch
  1109. p->thread_status = S_IDLE ;
  1110. } //for
  1112. free((void*)pBindBuffer) ;
  1113. GetHandles(&stHandles, FREE, 0) ;
  1114. p->thread_status = S_EXIT ;
  1115. return 0 ;
  1116. };
  1120. /*************************************************
  1121. Function: CreateDemoTable
  1122. *************************************************/
  1123. SQLRETURN CreateDemoTables(char* szTableName, int nTables, table_opt op){
  1125.     SQLRETURN retcode = SQL_ERROR ;
  1126.     SQLCHAR szStmtBuffer[MAX_SQL_STMT] = { 0 } ;
  1127.     SQLCHAR szColBuffer[MAX_COL_NAME] = { 0 } ;
  1128. SQLCHAR szAuxBuffer[32] = { 0 } ;
  1129.     ODBC_HANDLES stHandles ;
  1130.     memset(&stHandles, 0, sizeof(ODBC_HANDLES)) ;
  1131.     int c = 0  ;
  1133. GetHandles(&stHandles, GET, 0) ;
  1135.     if(CREATE == op){
  1137.         for(c = 0; c < nTables ; ++c){
  1138. sprintf((char*)szStmtBuffer, "CREATE TABLE %s (", (char*)(szTableName+MAX_TABLE_NAME*c)) ;
  1139.             int j = 0 ;
  1140. for(;;){
  1141. sprintf((char*)szColBuffer, "COL%d ", j) ;
  1142.                 strcat((char*)szStmtBuffer, (char*)szColBuffer) ;
  1143.                 ++j ;
  1145.                 switch(AttributeType){
  1146.                     case T_INT:
  1147.                         strcat((char*)szStmtBuffer, "INTEGER") ;
  1148.                         break ;
  1149.                     case T_FLOAT:
  1150.                         strcat((char*)szStmtBuffer, "FLOAT") ;
  1151.                         break ;
  1153. /*                    case T_DOUBLE:
  1154.                         strcat((char*)szStmtBuffer, "DOUBLE") ;
  1155.                         break ;
  1156. */
  1157.                     case T_CHAR:
  1158. sprintf((char*)szAuxBuffer, "CHAR(%d)", MAX_CHAR_ATTR_LEN) ;
  1159. strcat((char*)szStmtBuffer,  (char*)szAuxBuffer) ;
  1160.                         break ;
  1161.                     default:
  1162.                         break ;
  1163. }
  1165. if(nNoOfCol <= j){
  1166. strcat((char*)szStmtBuffer, ")") ;
  1167. break ;
  1168. }
  1169. strcat((char*)szStmtBuffer, ", ") ;
  1170.             } //for(;;)
  1173. if(nPrint) printf("n> %sn", szStmtBuffer) ;
  1174. ODBC_FN(SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS), retcode) ;
  1175. if(SQL_SUCCESS != retcode) HandleError(stHandles.hstmt , SQL_HANDLE_STMT) ;
  1178. }// for()
  1180. }else{
  1182. for(c = 0 ; c < nTables ; ++c){
  1183. sprintf((char*)szStmtBuffer, "DROP TABLE %s ", (char*)(szTableName + MAX_TABLE_NAME*c)) ;
  1184. //ODBC_FN(SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS), retcode) ;
  1185. if(nPrint) printf("n> %sn", szStmtBuffer) ;
  1186. retcode = SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS) ;
  1187. }
  1189. }
  1191.     GetHandles(&stHandles, FREE, 0) ;
  1193.     return retcode ;
  1194. }
  1198. /*************************************************
  1199. Function: AssignTableNames()
  1200. *************************************************/
  1201. inline void AssignTableNames(char* szBuffer, int nTables){
  1202.     for(int c = 0 ; c < nTables ; ++c){
  1203.         sprintf((char*)(szBuffer + MAX_TABLE_NAME*sizeof(char)*c), "TAB%d", c) ;
  1204.         }
  1205. return ;
  1206.     }
  1211. /*************************************************
  1212. Function: StartThreads()
  1213. *************************************************/
  1215. inline void StartThreads(PARAMS* p, void* pRef, int nTables, char* szTables, attr_type attrType, UintPtr* pHandles) {
  1217.     int* pInt = NULL ;
  1218.     float* pFloat = NULL ;
  1219.     double* pDouble = NULL ;
  1220.     char* pChar = NULL ;
  1221. UintPtr pTmpThread = NULL ;
  1223.     bool bFlap = 1 ;
  1224.     for(int f = 0 ; f < nNoOfThreads ; ++f){
  1225.         p[f].nThreadID = f ;
  1226.         p[f].nError = 0 ;
  1227.         p[f].thread_status = S_IDLE ;
  1228.         p[f].op_type = T_WAIT ;
  1229.         if(bFlap){
  1230. strncpy((char*)p[f].szTableName, (char*)szTables, MAX_TABLE_NAME) ;
  1231. }else{
  1232.             strncpy((char*)p[f].szTableName, (char*)(szTables + MAX_TABLE_NAME*sizeof(char)), MAX_TABLE_NAME) ;
  1233. }
  1234.         bFlap = !bFlap ;
  1235. //pTmpThread = pHandles[ ;
  1237.         switch(attrType){
  1238.             case T_INT:
  1239.                 pInt = (int*)pRef ;
  1240.                 p[f].pThreadRef = (void*)&pInt[nNoOfRows*nNoOfCol*f] ;
  1241.                 pHandles[f] = (UintPtr)NdbThread_Create(ThreadFnInt, (void**)&p[f], 32768, "SQL99_test", NDB_THREAD_PRIO_MEAN) ;
  1242.                 break ;
  1243.             case T_FLOAT:
  1244.                 pFloat = (float*)pRef ;
  1245.                 p[f].pThreadRef = (void*)&pFloat[nNoOfRows*nNoOfCol*f] ;
  1246.                 pHandles[f] = (UintPtr)NdbThread_Create(ThreadFnFloat, (void**)&p[f], 32768, "SQL99_test", NDB_THREAD_PRIO_MEAN) ;
  1247.                 break ;
  1248.             /*
  1249. case T_DOUBLE:
  1250.                 pDouble = (double*)pRef ;
  1251.                 p[f].pThreadRef = (void*)&pDouble[nNoOfRows*nNoOfCol*f] ;
  1252.                 pHandles[f] = (UintPtr)NdbThread_Create(ThreadFnDouble, (void**)&p[f], 32768, "SQL99_test", NDB_THREAD_PRIO_MEAN) ;
  1253.                 break ;
  1254. */
  1255.             case T_CHAR:
  1256.                 pChar = (char*)pRef ;
  1257.                 p[f].pThreadRef = (void*)&pChar[nNoOfRows*nNoOfCol*f*MAX_CHAR_ATTR_LEN] ;
  1258.                 pHandles[f] = (UintPtr)NdbThread_Create(ThreadFnChar,  (void**)&p[f], 32768, "SQL99_test", NDB_THREAD_PRIO_MEAN) ;
  1259.             default:
  1260.                 break ;
  1261.             }
  1262.     while(!(S_STARTED != p[f].report_status || S_EXIT != p[f].report_status)){
  1263.         NdbSleep_MilliSleep(1) ;
  1264. }
  1265.         }
  1266. return ;
  1267. }
  1271. /*************************************************
  1272. Function: SetThreadOperationType()
  1273. *************************************************/
  1274. inline void SetThreadOperationType(PARAMS* p, type op){
  1276.     for(int e = 0 ; e < nNoOfThreads ; ++e){
  1277.         p[e].nVerifyFlag = 0 ;
  1278.         if(T_READ_VERIFY == op){
  1279.             p[e].nVerifyFlag = 1 ;
  1280.             p[e].op_type = T_READ ;
  1281.             }else if(T_DELETE_VERIFY == op){
  1282.                 p[e].nVerifyFlag = 1 ;
  1283.                 p[e].op_type = T_DELETE ;
  1284.                 }else{
  1285.                     p[e].op_type = op ;
  1286.                     }
  1287.             p[e].thread_status = S_GET_BUSY ;
  1288.         }
  1289. return ;
  1290.     }
  1294. /*************************************************
  1295. Function: WaitForThreads()
  1296. *************************************************/
  1297. inline int WaitForThreads(PARAMS* p) {
  1299. int ret_value = 0 ;
  1300.     for(int w = 0 ; w < nNoOfThreads ; ++w){
  1301.         while(!(S_IDLE != p[w].thread_status || S_EXIT != p[w].report_status)) {
  1302.             NdbSleep_MilliSleep(1) ;
  1303. }
  1304. ret_value += p[w].nError ;
  1305. }
  1306. return ret_value ;
  1307. }
  1311. /*************************************************
  1312. Function: StopThreads()
  1313. *************************************************/
  1314. inline void StopThreads(PARAMS* p, UintPtr* pHandles) {
  1316.     for(int k = 0 ; k < nNoOfThreads ; ++k){
  1317. while(!(S_IDLE != p[k].thread_status || S_EXIT != p[k].report_status)){
  1318. NdbSleep_MilliSleep(1) ;
  1319. }
  1320. p[k].thread_status = S_STOP ;
  1321. while(!(S_EXIT != p[k].thread_status || S_EXIT != p[k].report_status)){
  1322. NdbSleep_MilliSleep(1) ;
  1323. }
  1324. NdbThread_Destroy((NdbThread**)&pHandles[k]) ;
  1325. }
  1327. return ;
  1328. }
  1332. /*************************************************
  1333. Function: PrintAll()
  1334. *************************************************/
  1335. inline void PrintAll(char* szTableName, int nTables, attr_type attrType){
  1337.     SQLRETURN retcode = SQL_ERROR ;
  1338.     SQLCHAR* szStmt[MAX_SQL_STMT] = { 0 } ;
  1339.     ODBC_HANDLES stHandles ;
  1340.     memset(&stHandles, 0, sizeof(ODBC_HANDLES)) ;
  1341.     double* pDoubleBuffer = NULL ;
  1342.     char* pCharBuffer = NULL ;
  1344.     if(T_CHAR != attrType){
  1345.         pDoubleBuffer = (double*)malloc(sizeof(double)*nNoOfCol) ;
  1346. }else{
  1347.          pCharBuffer = (char*)malloc(sizeof(char)*nNoOfCol*MAX_CHAR_ATTR_LEN) ;
  1348. }
  1350.     SQLINTEGER   cbLen = 0 ;
  1352.     GetHandles(&stHandles, GET, 0) ;
  1354.     for(int c = 0 ; c < nTables ; ++c){
  1356.         int nCol = 0, nRows = 0 ;
  1358.         printf("Table: "%s":n------------------n", (char*)(szTableName + MAX_TABLE_NAME*c*sizeof(char))) ;
  1360.         sprintf((char*)szStmt, "SELECT * FROM %s", (char*)(szTableName + MAX_TABLE_NAME*c*sizeof(char))) ;
  1361. if(nPrint) printf("n> %sn", szStmt) ;
  1362.         ODBC_FN(SQLExecDirect(stHandles.hstmt, (SQLCHAR*)szStmt, SQL_NTS), retcode) ;
  1364.         for(int i = 0 ; i < nNoOfCol ; ++i){
  1366.             if(T_CHAR != attrType){
  1367.                 ODBC_FN(SQLBindCol(stHandles.hstmt, (i+1), SQL_C_DOUBLE, (void*)&pDoubleBuffer[i], sizeof(SQLDOUBLE), &cbLen), retcode) ;
  1368. }else{
  1369.                 ODBC_FN(SQLBindCol(stHandles.hstmt, (i+1), SQL_C_CHAR, (void*)(pCharBuffer + i*MAX_CHAR_ATTR_LEN*sizeof(char)), MAX_CHAR_ATTR_LEN*sizeof(char), &cbLen), retcode) ;
  1370. }
  1371.             nCol++ ;
  1373. }
  1375.     int k = 0 ; //out of the <for> loop
  1376.     for (;;) {
  1378.         retcode = SQLFetch(stHandles.hstmt);
  1379.         if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode ){
  1380.             for(k = 0 ; k < nNoOfCol ; ++k){
  1381.                 if(T_CHAR != attrType){
  1382.                     ATTR_TYPE_SWITCH_T(pDoubleBuffer[k], AttributeType) ;
  1383.                     }else{
  1384.                         printf("%st", (char*)(pCharBuffer + k*MAX_CHAR_ATTR_LEN)) ;
  1385. }
  1386.                 }
  1387.             }else if(SQL_NO_DATA == retcode){
  1388.                 if(0 == k){
  1389.                     printf("<empty>n") ;
  1390.                     break ;
  1391.                     }else{
  1392.                         break ;
  1393. }
  1394.                 }else{
  1395.                     HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
  1396. }
  1398.             ++nRows ;
  1399.             printf("n") ;
  1400.         }
  1402. SQLCloseCursor(stHandles.hstmt) ;
  1404. printf("------------------n") ;
  1405. printf("Rows: %d Columns: %dnn", nRows, nCol) ;
  1407. }
  1409. free((void*)pDoubleBuffer) ;
  1410. free((void*)pCharBuffer) ;
  1411. GetHandles(&stHandles, FREE, 0) ;
  1413. return ;
  1414. }
  1418. /*************************************************
  1419. Function: AssignRefCharValues()
  1420. *************************************************/
  1421. void AssignRefCharValues(char* pRef, bool bVerbose) {
  1423.     int count = 0, rows = 0, nThreadOffset = 0, nRowOffset = 0 ;
  1424.     char szStrBuffer[MAX_CHAR_ATTR_LEN] = { 0 } ;
  1425.     int char_count = sizeof(szANSI)/sizeof(char) ;
  1427.     for(int c = 0 ; c < nNoOfThreads ; ++c){
  1428.         nThreadOffset = nNoOfRows*nNoOfCol*c*MAX_CHAR_ATTR_LEN*sizeof(char) ;
  1429.         for(int d = 0 ; d < nNoOfRows ; ++d){
  1430.             nRowOffset = nNoOfCol*d*MAX_CHAR_ATTR_LEN*sizeof(char) ; ++rows ;
  1431.             for(int i = 0 ; i < nNoOfCol ; ++i){
  1432.                 for(int j = 0 ; j < (MAX_CHAR_ATTR_LEN - 2) ; ++j){
  1433.                     int h = (char)(rand() % (char_count-1)) ;
  1434.                     szStrBuffer[j] = szANSI[h] ;
  1435.                     }
  1436.             szStrBuffer[MAX_CHAR_ATTR_LEN - 1] = '' ;
  1438.             strcpy((char*)(pRef + nThreadOffset + nRowOffset + i*MAX_CHAR_ATTR_LEN*sizeof(char)), (char*)szStrBuffer) ;
  1439.             count++ ;
  1440.             if(bVerbose){
  1441.                 printf(" %s ", (char*)(pRef + nThreadOffset + nRowOffset + i*MAX_CHAR_ATTR_LEN*sizeof(char))) ;
  1442.                 }
  1443.                 }
  1444.         if(bVerbose) { 
  1445.             printf("n") ;
  1446.             NdbSleep_MilliSleep(10) ;
  1447.             }
  1448.             }
  1449.         }
  1451. if(bVerbose){
  1452.     printf("_____________________") ;
  1453.     printf("nRows: %d Values: %dnn", rows, count) ;
  1454.     }
  1456. return ;
  1457.     }
  1460. /*
  1463. sprintf((char*)szStmtBuffer, "INSERT INTO %s VALUES(", p->szTableName) ; 
  1464. for(j = 0 ;;){
  1465. strcat((char*)szStmtBuffer, "?") ;
  1466. ++j ;
  1467. if(nNoOfCol == j) break ;
  1468. strcat((char*)szStmtBuffer, ", ") ;
  1469. }
  1470. strcat((char*)szStmtBuffer, ")") ;
  1472. ODBC_FN(SQLPrepare(stHandles.hstmt, szStmtBuffer, SQL_NTS), retcode) ;
  1474. for(j = 0 ; j < nNoOfCol ; ++j){
  1475. ODBC_FN(SQLBindParameter(stHandles.hstmt, (j+1), SQL_PARAM_INPUT, SQL_C_FLOAT, SQL_FLOAT, 0, 0, (void*)&pBindBuffer[j], 0, &cbFloat), retcode) ;
  1476. HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
  1477. }
  1479. for(r = 0 ; r < nNoOfRows ; ++r){
  1480. for(j = 0 ; j < nNoOfCol ; ++j){
  1481. pBindBuffer[j] = pRef[nNoOfCol*r + j] ;
  1482. }
  1483. ODBC_FN(SQLExecute(stHandles.hstmt), retcode) ;
  1484. HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
  1485. }
  1487. */
  1492. /*************************************************
  1493. Function: HandleError
  1494. *************************************************/
  1496. void HandleError(void* handle, SQLSMALLINT HandleType){
  1498.     SQLCHAR szError[MAX_STR_LEN], szSqlState[32] ;
  1499.     SQLINTEGER nError = 0 ;
  1500.     SQLSMALLINT nHandleType = HandleType ;
  1501.     SQLSMALLINT nLength = 0 ;
  1502.     SQLHANDLE SQLHandle = handle ;
  1503.     SQLGetDiagRec(nHandleType, SQLHandle, 1, szSqlState, &nError, szError, 128, &nLength) ;
  1504.     printf("Error: %snSqlState: %sn", szError, szSqlState) ;
  1506.     return ;
  1507.     }
  1511. /*************************************************
  1512. Function: ReportError
  1513. *************************************************/
  1515. void ReportError(char* szFn, char* szBuffer, char* szFile, int iLine){
  1517.     printf("%s %snFile: %snLine: %dn", szFn, szBuffer, szFile, iLine) ;
  1519.     return ;
  1520. }
  1524. /*************************************************
  1525. Function: GetHandles()
  1526. *************************************************/
  1528. SQLRETURN GetHandles(ODBC_HANDLES* pHandles, handle_op op, bool bDriverInfo){
  1530.     SQLRETURN   retcode = SQL_ERROR ;
  1532.     if(GET == op){
  1534. retcode = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &pHandles->henv);
  1536.         if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode ) {
  1537. retcode = SQLSetEnvAttr(pHandles->henv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC2, 0);
  1539.             if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode) {
  1540. retcode = SQLAllocHandle(SQL_HANDLE_DBC, pHandles->henv, &pHandles->hdbc);
  1542.                 if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode) {
  1543.                     
  1544. //SQLSetConnectAttr(pHandles->hdbc, SQL_LOGIN_TIMEOUT, (void*)5, 0);
  1546. retcode = SQLConnect(pHandles->hdbc, (SQLCHAR*)"", SQL_NTS, (SQLCHAR*)"", SQL_NTS, (SQLCHAR*)"", SQL_NTS ) ;
  1548. SQL_SUCCESS == SQLSetConnectAttr(pHandles->hdbc, SQL_ATTR_AUTOCOMMIT, (void*)SQL_AUTOCOMMIT_ON, 0) ;
  1549. //printf("AUTOCOMMIT is onn") ; 
  1551. if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode) {
  1552. // retcode still holds the value returned by SQLConnect
  1553.     retcode = SQLAllocHandle(SQL_HANDLE_STMT, pHandles->hdbc, &pHandles->hstmt) ;
  1554. if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode) {
  1555. if(bDriverInfo) GetDriverAndSourceInfo(pHandles->hdbc) ;
  1556. // printf("All handles allocated OKn", retcode);
  1557. }else{ // SQLAllocHandle()
  1558. REPORTERROR((char*)"SQLAllocHandle()", (char*)"failed") ;
  1559. HandleError(pHandles->hdbc, SQL_HANDLE_DBC) ;
  1560. ODBC_FN(SQLDisconnect(pHandles->hdbc), retcode) ;
  1561. ODBC_FN(SQLFreeHandle(SQL_HANDLE_DBC, pHandles->hdbc), retcode) ;
  1562. ODBC_FN(SQLFreeHandle(SQL_HANDLE_ENV, pHandles->henv), retcode) ;
  1563. retcode = SQL_ERROR ;
  1564. }
  1565. }else{ // SQLConnect()
  1566. REPORTERROR((char*)"SQLConnect()", (char*)"failed" ) ;
  1567. HandleError(pHandles->hdbc, SQL_HANDLE_DBC) ;
  1568. ODBC_FN(SQLFreeHandle(SQL_HANDLE_DBC, pHandles->hdbc), retcode) ;
  1569. ODBC_FN(SQLFreeHandle(SQL_HANDLE_ENV, pHandles->henv), retcode) ;
  1570. retcode = SQL_ERROR ;
  1571. }
  1572. }else{ // SQLAllocHandle()
  1573. REPORTERROR((char*)"SQLAllocHandle()", "failed" ) ;
  1574. HandleError(pHandles->hdbc, SQL_HANDLE_DBC) ;
  1575. ODBC_FN(SQLFreeHandle(SQL_HANDLE_ENV, pHandles->henv), retcode) ;
  1576. retcode = SQL_ERROR ;
  1577. }
  1578. }else{ // SQLSetEnvAttr()
  1579. REPORTERROR((char*)"SQLSetEnvAttr()", "failed" ) ;
  1580. HandleError(pHandles->henv, SQL_HANDLE_ENV) ;
  1581. ODBC_FN(SQLFreeHandle(SQL_HANDLE_ENV, pHandles->henv), retcode) ;
  1582. retcode = SQL_ERROR ;
  1583. }
  1584. }else{ // SQLAllocHandle()
  1585. REPORTERROR((char*)"SQLAllocHandle()", "failed" ) ;
  1586. HandleError(pHandles->henv, SQL_HANDLE_ENV) ;
  1587. retcode = SQL_ERROR ;
  1588. }
  1589. }else{
  1590. ODBC_FN(SQLFreeHandle(SQL_HANDLE_STMT, pHandles->hstmt), retcode) ;
  1591. ODBC_FN(SQLDisconnect(pHandles->hdbc), retcode) ;
  1592. ODBC_FN(SQLFreeHandle(SQL_HANDLE_DBC, pHandles->hdbc), retcode) ;
  1593. ODBC_FN(SQLFreeHandle(SQL_HANDLE_ENV, pHandles->henv), retcode) ;
  1594. }
  1596.     return retcode ;
  1597. }
  1601. /*************************************************
  1602. Function: AggretateFn():
  1603. <aggr_fn fn> - name of the aggregate function to use
  1604. <char* szTableName> - name of the table
  1605. <int nCol> - number of the column
  1606. <double* pdIn> - pointer to double containing the value to be used in a call to COUNT; used only by this function
  1607. <double* pdOut> - pointer to double that will recieve the result
  1608. <attr_type attrType> - type of the attribute
  1609. *************************************************/
  1610. SQLRETURN AggregateFn(aggr_fn fn, char* szTableName, int nCol, double* pdIn, double* pdOut, attr_type attrType){
  1612.     SQLRETURN retcode = SQL_ERROR ;
  1613.     SQLCHAR* szStmt[MAX_SQL_STMT] = { 0 } ;
  1614.     SQLCHAR szValueBuffer[MAX_VALUE_LEN] = { 0 } ;
  1615.     SQLCHAR szAuxBuffer[MAX_STR_LEN] = { 0 } ;
  1616.     SQLCHAR szColBuffer[MAX_COL_NAME] = { 0 } ;
  1617.     ODBC_HANDLES stHandles ;
  1618.     memset(&stHandles, 0, sizeof(ODBC_HANDLES)) ;
  1619.     SQLINTEGER  cbDouble = 0 ;
  1621.     GetHandles(&stHandles, GET, 0) ;
  1623.     switch(fn){
  1624.     case FN_COUNT:
  1625.         switch(attrType){
  1626.     case T_INT:
  1627.         sprintf((char*)szStmt, "SELECT COUNT(*) FROM %s WHERE COL%d > %d", szTableName, nCol, (int)*pdIn) ;
  1628.         break ;
  1629.     case T_FLOAT:
  1630.         sprintf((char*)szStmt, "SELECT COUNT(*) FROM %s WHERE COL%d > %f", szTableName, nCol, (float)*pdIn) ;
  1631.         break ;
  1632. /*    case T_DOUBLE:
  1633.         sprintf((char*)szStmt, "SELECT COUNT(*) FROM %s WHERE COL%d > %.15f", szTableName, nCol, *pdIn) ;
  1634.         break ;
  1635. */
  1636.     default:
  1637.         break ;
  1638.             }
  1639.     break ;
  1640.     case FN_SUM:
  1641.         sprintf((char*)szStmt, "SELECT SUM(COL%d) FROM %s", nCol, szTableName) ;
  1642.         break ;
  1643.     case FN_AVG:
  1644.         sprintf((char*)szStmt, "SELECT AVG(COL%d) FROM %s", nCol, szTableName) ;
  1645.         break ;
  1646.     case FN_MAX:
  1647.         sprintf((char*)szStmt, "SELECT MAX(COL%d) FROM %s", nCol, szTableName) ;
  1648.         break ;
  1649.     case FN_MIN:
  1650.         sprintf((char*)szStmt, "SELECT MIN(COL%d) FROM %s", nCol, szTableName) ;
  1651.         break ;
  1652.     case FN_VARIANCE: // not implemented
  1653.         //sprintf((char*)szStmt, "SELECT VARIANCE(COL%d) FROM %s;", nCol, szTableName) ;
  1654.         break ;
  1655.     case FN_STDDEV: // not implemented
  1656.         //sprintf((char*)szStmt, "SELECT STDDEV(COL%d) FROM %s;", nCol, szTableName) ;
  1657.         break ;
  1658.     default:
  1659.         break ;
  1660.         }
  1661. //printf("%sn", szStmt) ; 
  1663. retcode = SQLExecDirect(stHandles.hstmt, (SQLCHAR*)szStmt, SQL_NTS) ;
  1664. if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode ){
  1665.     retcode = SQLBindCol(stHandles.hstmt, 1, SQL_C_DOUBLE, (void*)pdOut, sizeof(SQLDOUBLE), &cbDouble) ;
  1666.     if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode ){
  1667.         retcode = SQLFetch(stHandles.hstmt) ;
  1668.         }
  1669.     }
  1671. if(SQL_SUCCESS != retcode && SQL_SUCCESS_WITH_INFO != retcode){
  1672.     HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
  1673.     }
  1675. SQLCloseCursor(stHandles.hstmt) ;
  1677. GetHandles(&stHandles, FREE, 0) ;
  1679. return retcode ;
  1681.     };
  1685. /*************************************************
  1686. Function: GetDriverAndSourceInfo()
  1687. *************************************************/
  1688. SQLRETURN GetDriverAndSourceInfo(SQLHDBC hdbc){
  1690.     SQLRETURN retcode = SQL_ERROR ;
  1692.     SQLCHAR buffer[255] ;
  1693.     SQLUSMALLINT snValue = 0 ;
  1694.     SQLSMALLINT outlen =  0 ;
  1696.     printf( "-------------------------------------------n" ) ;
  1698.     retcode = SQLGetInfo( hdbc, SQL_DATA_SOURCE_NAME, buffer, 255, &outlen ) ;
  1700.     printf( "Connected to Server: %sn", buffer ) ;
  1702.     retcode = SQLGetInfo( hdbc, SQL_DATABASE_NAME, buffer, 255, &outlen ) ;
  1703.     printf( "      Database name: %sn", buffer ) ;
  1705.     retcode = SQLGetInfo( hdbc, SQL_SERVER_NAME, buffer, 255, &outlen ) ;
  1706.     printf( "      Instance name: %sn", buffer ) ;
  1708.     retcode = SQLGetInfo( hdbc, SQL_DBMS_NAME, buffer, 255, &outlen ) ;
  1709.     printf( "          DBMS name: %sn", buffer ) ;
  1711.     retcode = SQLGetInfo( hdbc, SQL_DBMS_VER, buffer, 255, &outlen ) ;
  1712.     printf( "       DBMS version: %sn", buffer ) ;
  1714.     retcode = SQLGetInfo( hdbc, SQL_ODBC_VER, buffer, 255, &outlen ) ;
  1715.     printf( "       ODBC version: %sn", buffer ) ;
  1717.     retcode = SQLGetInfo( hdbc, SQL_DRIVER_NAME, buffer, 255, &outlen ) ;
  1718.     printf( "        Driver name: %sn", buffer ) ;
  1720.     retcode = SQLGetInfo( hdbc, SQL_DRIVER_VER, buffer, 255, &outlen ) ;
  1721.     printf( "     Driver version: %sn", buffer ) ;
  1723.     retcode = SQLGetInfo( hdbc, SQL_MAX_DRIVER_CONNECTIONS, &snValue, sizeof(SQLSMALLINT), &outlen ) ;
  1724.     printf( "    Max connections: %dn", snValue ) ;
  1726.     retcode = SQLGetInfo( hdbc, SQL_CURSOR_COMMIT_BEHAVIOR, &snValue, sizeof(SQLSMALLINT), &outlen ) ;
  1727.     printf( "Autocommit behavior:") ;
  1729.     switch(snValue){
  1730.     case SQL_CB_DELETE:
  1731.         printf(" SQL_CB_DELETEn") ;
  1732.         break ;
  1733.     case SQL_CB_CLOSE:
  1734.         printf(" SQL_CB_CLOSEn") ;
  1735.         break ;
  1736.     case SQL_CB_PRESERVE:
  1737.         printf(" SQL_CB_PRESERVEn") ;
  1738.         break ;
  1739.     default:
  1740.         printf(" undefinedn") ;
  1741.         break ;
  1742.         }
  1744. printf( "-------------------------------------------n" ) ;
  1746. return retcode ;
  1748. }
  1752. /*************************************************
  1753. Function: ArithOp()
  1754. *************************************************/
  1756. int ArithOp(char* szTable, int nTotalCols, float* pValue, attr_type attrType, arth_op op){
  1758.     SQLRETURN retcode = SQL_ERROR ;
  1759. int nVerRet = -1 ;
  1760.     SQLCHAR szStmt[MAX_SQL_STMT] = { 0 } ;
  1761.     SQLCHAR szEndBuffer[MAX_STR_LEN] = { 0 } ;
  1762.     SQLCHAR szColBuffer[MAX_COL_NAME] = { 0 } ;
  1763.     SQLCHAR szAuxBuffer[MAX_STR_LEN] = { 0 } ;
  1764.     ODBC_HANDLES stHandles ;
  1765.     memset(&stHandles, 0, sizeof(ODBC_HANDLES)) ;
  1767.     void* pBuffer = NULL ;
  1768.     SQLINTEGER BindInt = 0, IntResult = 0, RefIntResult = 0 ;
  1769.     SQLFLOAT BindFloat = 0, FloatResult = 0, RefFloatResult = 0 ;
  1770.     SQLDOUBLE BindDouble = 0, DoubleResult = 0, RefDoubleResult = 0 ;
  1771.     SQLINTEGER cbSize = 0 ;
  1772.     SQLINTEGER  cbLen = 0 ;
  1773.     SQLSMALLINT cbTarget = 0 ;
  1775.     GetHandles(&stHandles, GET, 0) ;
  1777.     for(int c = 0 ; c < nTotalCols ; ++c){
  1779. sprintf((char*)szStmt, "SELECT COL%d, (COL%d", c, c) ;
  1780.         switch(op){
  1781.         case MINUS:
  1782.             strcat((char*)szStmt, " - ") ;
  1783.             break ;
  1784.         case PLUS:
  1785.             strcat((char*)szStmt, " + ") ;
  1786.             break ;
  1787.         case MULTI:
  1788.             strcat((char*)szStmt, " * ") ;
  1789.             break ;
  1790.         case DIVIDE:
  1791.             strcat((char*)szStmt, " / ") ;
  1792.             break ;
  1793.         case MODULO:
  1794.             //strcat((char*)szStmt, " % ") ; Not implemented
  1795.             GetHandles(&stHandles, FREE, 0) ;
  1796.             return -1 ; //Close handles and return
  1797.             break ;
  1798.         default:
  1799.             break ;
  1800. }
  1802. sprintf((char*)(szAuxBuffer),"%.9f) ", *((float*)(pValue))) ;
  1803. strcat((char*)szStmt, (char*)szAuxBuffer) ;
  1804. sprintf((char*)szEndBuffer, "FROM %s", szTable) ;
  1805. strcat((char*)szStmt, (char*)szEndBuffer) ;
  1807. ODBC_FN(SQLExecDirect(stHandles.hstmt, (SQLCHAR*)szStmt, SQL_NTS), retcode) ;
  1808. if(retcode == SQL_ERROR){
  1809. HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ; 
  1810. printf("n%sn", szStmt) ;
  1811. }
  1813. SQLSMALLINT cbNameLen = 0, cbSqlType = 0, cbNullable = 0, cbColScale = 0  ;
  1814. SQLINTEGER cbColSize = 0 ;
  1815. SQLDescribeCol(stHandles.hstmt, 2, szColBuffer, MAX_COL_NAME-1, &cbNameLen, &cbSqlType, (unsigned long*)&cbColSize, &cbColScale, &cbNullable) ;
  1817. switch(cbSqlType){
  1818. case SQL_NUMERIC:
  1819. pBuffer = &IntResult ;
  1820. cbSize = sizeof(SQLINTEGER) ;
  1821. cbTarget = SQL_C_ULONG ;
  1822. case SQL_INTEGER:
  1823. pBuffer = &IntResult ;
  1824. cbSize = sizeof(SQLINTEGER) ;
  1825. cbTarget = SQL_C_LONG ;
  1826. break ;
  1827. case SQL_FLOAT:
  1828. pBuffer = &FloatResult ; 
  1829. cbSize = sizeof(SQLFLOAT) ;
  1830. cbTarget = SQL_C_FLOAT ;
  1831. break ;
  1832. case SQL_DOUBLE:
  1833. pBuffer = &DoubleResult ;
  1834. cbSize = sizeof(SQLDOUBLE) ;
  1835. cbTarget = SQL_C_DOUBLE ;
  1836. break ;
  1837. default:
  1838. printf("nUndefined result type: %dn", cbSqlType) ;
  1839. break ;
  1840. }
  1842. switch(attrType){
  1843. case T_INT:
  1844. ODBC_FN(SQLBindCol(stHandles.hstmt, 1, SQL_C_SLONG, (void*)&BindInt, sizeof(SQLINTEGER), &cbLen), retcode) ;
  1845. break ;
  1846. case T_FLOAT:
  1847. ODBC_FN(SQLBindCol(stHandles.hstmt, 1, SQL_C_FLOAT, (void*)&BindFloat, sizeof(SQLFLOAT), &cbLen), retcode) ;
  1848. break ;
  1849. /*        case T_DOUBLE:
  1850. ODBC_FN(SQLBindCol(stHandles.hstmt, 1, SQL_C_DOUBLE, (void*)&BindDouble, sizeof(SQLDOUBLE), &cbLen), retcode) ;
  1851. break ;
  1852. */
  1853. default:
  1854. break ;
  1855. }
  1857. ODBC_FN(SQLBindCol(stHandles.hstmt, 2, cbTarget, pBuffer, cbSize, &cbLen), retcode) ;
  1859. retcode = SQLFetch(stHandles.hstmt) ;
  1861. if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
  1862. switch(attrType){
  1863. case T_INT:
  1864. switch(cbSqlType){
  1865. case SQL_INTEGER:
  1866. nVerRet = VerifyArthOp((int*)&BindInt, pValue, (int*)pBuffer, op) ;
  1867. break ;
  1868. case SQL_FLOAT:
  1869. nVerRet = VerifyArthOp((int*)&BindInt, pValue, (float*)pBuffer, op) ;
  1870. break ;
  1871. case SQL_DOUBLE:
  1872. nVerRet = VerifyArthOp((int*)&BindInt, pValue, (double*)pBuffer, op) ;
  1873. break ;
  1874. case SQL_NUMERIC:
  1875. nVerRet = VerifyArthOp((int*)&BindInt, pValue, (int*)pBuffer, op) ;
  1876. break ;
  1877. default:
  1878. break ;
  1879. }
  1880. break ;
  1882. case T_FLOAT:
  1883. switch(cbSqlType){
  1884. case SQL_INTEGER:
  1885. nVerRet = VerifyArthOp((float*)&BindFloat, pValue, (int*)pBuffer, op) ;
  1886. break ;
  1887. case SQL_FLOAT:
  1888. nVerRet = VerifyArthOp((float*)&BindFloat, pValue, (float*)pBuffer, op) ;
  1889. break ;
  1890. case SQL_DOUBLE:
  1891. nVerRet = VerifyArthOp((float*)&BindFloat, pValue, (double*)pBuffer, op) ;
  1892. break ;
  1893. default:
  1894. break ;
  1895. }
  1896. break ;
  1897. /*                case T_DOUBLE:
  1898. switch(cbSqlType){
  1899. case SQL_INTEGER:
  1900. nVerRet = VerifyArthOp((double*)&BindDouble, pValue, (int*)pBuffer, op) ;
  1901. break ;
  1902. case SQL_FLOAT:
  1903. nVerRet = VerifyArthOp((double*)&BindDouble, pValue, (float*)pBuffer, op) ;
  1904. break ;
  1905. case SQL_DOUBLE:
  1906. nVerRet = VerifyArthOp((double*)&BindDouble, pValue, (double*)pBuffer, op) ;
  1907. break ;
  1908. default:
  1909. break ;
  1910. }
  1911. break ;
  1912. */
  1913. default:
  1914. break ;
  1915. }
  1916. if(-1 == nVerRet){
  1917. printf("nVerification failed.n") ;
  1918. return nVerRet ;
  1919. }else if(SQL_NO_DATA == retcode){
  1920. break ;
  1921. }
  1922. }else{
  1924. HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
  1925. }
  1927. SQLCloseCursor(stHandles.hstmt) ;
  1928. }
  1930. GetHandles(&stHandles, FREE, 0) ;
  1932. return nVerRet ;
  1933. }
  1938. /*************************************************
  1939. Function: Join()
  1940. *************************************************/
  1941. SQLRETURN Join(char* szTable, int nTables, int nCol, join_type joinType){
  1943.     SQLRETURN retcode = SQL_ERROR ;
  1944.     SQLCHAR szStmt[MAX_SQL_STMT] = { 0 } ;
  1945.     SQLCHAR szEndBuffer[MAX_STR_LEN] = { 0 } ;
  1946.     SQLCHAR szColBuffer[MAX_COL_NAME] = { 0 } ;
  1947.     SQLCHAR szAuxBuffer[MAX_STR_LEN] = { 0 } ;
  1949.     ODBC_HANDLES stHandles ;
  1950.     memset(&stHandles, 0, sizeof(ODBC_HANDLES)) ;
  1952.     int c = 0, t = 0 ;
  1954.     GetHandles(&stHandles, GET, 0) ;
  1956.     for(c = 0 ; c < nCol ; ++c) {
  1958.         switch(joinType){
  1959.         case ITSELF:
  1960.             sprintf((char*)szStmt, "SELECT * FROM %s, %s", (char*)szTable, (char*)szTable) ;
  1961.             break ;
  1962.         case EQUI:
  1963.             break ;
  1964.         case NON_EQUI:
  1965.             break ;
  1966.         case INNER:
  1967.             break ;
  1968.         case OUTTER:
  1969.             break ;
  1970.         default:
  1971.             break ;
  1972.             }
  1973.         }
  1975. GetHandles(&stHandles, FREE, 0) ;
  1977. return retcode ;
  1979. }
  1983. SQLRETURN GetResults(SQLHSTMT){
  1985.     SQLRETURN retcode = SQL_ERROR ;
  1987.     return retcode ;
  1988. }
  1990. /*
  1992. int createTables(char* szTableName, int nTables){
  1993.   
  1994. for (int i = 0; i < nNoOfCol; i++){
  1995. snprintf(attrName[i], MAXSTRLEN, "COL%d", i) ;
  1996. }
  1998. for (int i = 0; i < nTables; i++){
  1999. snprintf(tableName[i], MAXSTRLEN, "TAB%d", i) ;
  2000. }
  2001.   
  2002. for(unsigned i = 0; i < nTables; i++){
  2004. ndbout << "Creating " << szTableName[i] << "... " ;
  2006. NDBT_Table tmpTable(szTableName[i]) ;
  2008. tmpTable.setStoredTable(!theTempTable) ;
  2009.     
  2010.    tmpTable.addAttribute(NDBT_Attribute(attrName[0],
  2011.                                     UnSigned,
  2012.                                     4, // 4 Bytes
  2013.                                     TupleKey));
  2014. }
  2017. for (int j = 1 ; j < nNoOfCol ; j++)
  2018. tmpTable.addAttribute(NDBT_Attribute(attrName[j], UnSigned, 4*tAttributeSize)) ;
  2020. if(tmpTable.createTableInDb(pMyNdb) == -1){
  2021. return -1 ;
  2022. }
  2023.     
  2024. ndbout << "done" << endl ;
  2026. return 0;
  2027. }
  2028. */
  2030. /*************************************************
  2031. Function: createTables()
  2032. Uses NDB API to create tables for the tests
  2033. *************************************************/
  2035. int createTables(char* szTableName, int nTables){
  2037.   Ndb * pNdb = new Ndb("TEST_DB") ;
  2038.   pNdb->init();
  2039.   
  2040.   ndbout << "Waiting for ndb to become ready..." <<endl;
  2041.   if (pNdb->waitUntilReady(10000) != 0){
  2042.     ndbout << "NDB is not ready" << endl;
  2043.     ndbout << "Benchmark failed!" << endl;
  2044.     delete pNdb ;
  2045. return -1 ;
  2046.   }
  2048.   NdbSchemaCon          *MySchemaTransaction = NULL ;
  2049.   NdbSchemaOp           *MySchemaOp = NULL ;
  2050.   int                   check = -1 ;
  2051.   char szColNameBuffer[MAX_COL_NAME] = { 0 } ;
  2052.   int tLoadFactor = 80 ;
  2053.   
  2054.   for(int i=0 ; i < nTables ; ++i) {
  2055.   
  2056.   ndbout << "Creating " << (char*)(szTableName+MAX_TABLE_NAME*i) << "..." << endl ;
  2058.       MySchemaTransaction = pNdb->startSchemaTransaction() ;
  2059.   //printf("MySchemaTransaction - OKn") ;
  2060.       if(MySchemaTransaction == NULL){
  2061.   printf("MySchemaTransaction is NULLn") ;
  2062.   delete pNdb ;
  2063.   return -1 ;
  2064.   }
  2065.       
  2066.       MySchemaOp = MySchemaTransaction->getNdbSchemaOp();       
  2067.      //printf("MySchemaTransaction->getNdb... - OKn") ;
  2068.       if(MySchemaOp == NULL){
  2069.      printf("MySchemaOp is NULLn") ;
  2070.   delete pNdb ;
  2071.   return -1 ;
  2072.   }
  2073.       
  2074.       check = MySchemaOp->createTable( (const char*)(szTableName+MAX_TABLE_NAME*i)
  2075.                                        ,8                       // Table Size
  2076.                                        ,TupleKey                // Key Type
  2077.                                        ,40                      // Nr of Pages
  2078.                                        ,All
  2079.                                        ,6
  2080.                                        ,(tLoadFactor - 5)
  2081.                                        ,(tLoadFactor)
  2082.                                        ,1
  2083.                                        ,0
  2084.                                        );
  2085.       
  2086.       if (check == -1){
  2087.     printf("MySchemaOp->createTable failedn") ;
  2088.   delete pNdb ;
  2089.   return -1 ;
  2090.   }
  2092.       snprintf(szColNameBuffer, MAX_COL_NAME, "COL%d", 0) ;
  2093.       check = MySchemaOp->createAttribute( szColNameBuffer,
  2094.                                            TupleKey,
  2095.                                            32,
  2096.                                            PKSIZE,
  2097.                                            UnSigned,
  2098.                                            MMBased,
  2099.                                            NotNullAttribute );
  2100.       
  2101.       if (check == -1){
  2102.      printf("MySchemaOp->createAttribute() #1 failedn") ;
  2103.   delete pNdb ;
  2104.   return -1 ;
  2105.   }
  2107.       for (int j = 1; j < nNoOfCol ; j++){
  2108.   snprintf(szColNameBuffer, MAX_COL_NAME, "COL%d", j) ;
  2109.   check = MySchemaOp->createAttribute(szColNameBuffer,
  2110.                                              NoKey,
  2111.                                              32,
  2112.                                              tAttributeSize,
  2113.                                              UnSigned,
  2114.                                              MMBased,
  2115.                                              NotNullAttribute );
  2117.   if (check == -1){
  2118.        printf("MySchemaOp->createAttribute() #2 failedn") ;
  2119.   delete pNdb ;
  2120.   return -1;
  2121.   }
  2122.       }
  2123.       
  2124.       if (MySchemaTransaction->execute() == -1){
  2125.       printf("MySchemaTransaction->execute() failedn") ;
  2126.   printf("%sn", MySchemaTransaction->getNdbError().message) ; 
  2127.   return -1 ;
  2128.   delete pNdb ;
  2129.   }
  2130.       
  2131.       pNdb->closeSchemaTransaction(MySchemaTransaction);
  2132.     }
  2133.   
  2134.   return 0;
  2135. }