test/odbc/Threads/ODBCThread.c

   1
   2 #include <iostream>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include <time.h>
   7 #include <sql.h>
   8 #include <sqlext.h>
   9 #include "NanoTimer.h"
  10 #define THREADS 5
  11 #define ITERATION 1000
  12 using namespace std;
  13
  14 #define DSN
  15
  16 NanoTimer timer;
  17
  18 void extract_error(
  19     char *fn,
  20     SQLHANDLE handle,
  21     SQLSMALLINT type)
  22 {
  23     SQLINTEGER   i = 0;
  24     SQLINTEGER   native;
  25     SQLCHAR      state[ 7 ];
  26     SQLCHAR      text[256];
  27     SQLSMALLINT  len;
  28     SQLRETURN    ret;
  29
  30     fprintf(stderr,
  31             "\n"
  32             "The driver reported the following diagnostics whilst running "
  33             "%s\n\n",
  34             fn);
  35
  36     do
  37     {
  38         ret = SQLGetDiagRec(type, handle, ++i, state, &native, text,
  39                             sizeof(text), &len );
  40         if (SQL_SUCCEEDED(ret))
  41             printf("%s:%ld:%ld:%s\n", state, i, native, text);
  42     }
  43     while( ret == SQL_SUCCESS );
  44 }
  45
  46 inline void
  47 check_error (SQLSMALLINT handleType, SQLHANDLE handle, int rc, int line)
  48 {
  49   if (rc)
  50     {
  51       cout << "Error " << rc << " at line: " << line << endl;
  52       SQLCHAR state[10];
  53       SQLINTEGER native;
  54       SQLCHAR mesg[300];
  55       int i=0;
  56       while (SQLGetDiagRec (handleType, handle, i++, state, &native, mesg, 300,
  57                             NULL) == SQL_SUCCESS)
  58         {
  59           mesg[299] = '\0';
  60           cout << "state: " << state << endl;
  61           cout << "native: " << native << endl;
  62           cout << "mesg: " << mesg << endl;
  63         }
  64       exit (1);
  65     }
  66 }
  67
  68
  69 inline void
  70 checkrc (int rc, int line)
  71 {
  72   if (rc)
  73     {
  74       cout << "Error " << rc << " at line: " << line << endl;
  75       exit (1);
  76     }
  77 }
  78
  79 void
  80 readWriteTrans (SQLHDBC hdbc)
  81 {
  82   int rc = SQLSetConnectAttr (hdbc, SQL_ATTR_ACCESS_MODE,
  83                               (SQLPOINTER) SQL_MODE_READ_WRITE, 0);
  84   checkrc (rc, __LINE__);
  85   rc = SQLEndTran (SQL_HANDLE_DBC, hdbc, SQL_COMMIT);
  86   checkrc (rc, __LINE__);
  87 }
  88
  89 void
  90 readOnlyTrans (SQLHDBC hdbc)
  91 {
  92   int rc = SQLSetConnectAttr (hdbc, SQL_ATTR_ACCESS_MODE,
  93                               (SQLPOINTER) SQL_MODE_READ_ONLY, 0);
  94   checkrc (rc, __LINE__);
  95   rc = SQLEndTran (SQL_HANDLE_DBC, hdbc, SQL_COMMIT);
  96   checkrc (rc, __LINE__);
  97 }
  98
  99 void *runInsertTest (void *massage)
 100 {
 101   int thno;
 102   thno =*(int*)massage;
 103   SQLHENV henv;
 104   SQLHDBC hdbc;
 105   SQLHSTMT hstmt;
 106   int rc;
 107   int iHolder;
 108   char sHolder[200];
 109   char sData[200];
 110   char *dsn = (char *) "DSN=test;";
 111
 112   rc = SQLAllocHandle (SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
 113   checkrc (rc, __LINE__);
 114   SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0);
 115
 116   rc = SQLAllocHandle (SQL_HANDLE_DBC, henv, &hdbc);
 117   checkrc (rc, __LINE__);
 118   rc = SQLConnect (hdbc,
 119                    (SQLCHAR *) dsn, SQL_NTS,
 120                    (SQLCHAR *) "root",
 121                    (SQLSMALLINT) strlen ("root"),
 122                    (SQLCHAR *) "manager",
 123                    (SQLSMALLINT) strlen (""));
 124
 125    SQLCHAR outstr[1024];
 126    SQLSMALLINT outstrlen;
 127   if (SQL_SUCCEEDED(rc)) {
 128    // printf("Connected\n");
 129     if (rc == SQL_SUCCESS_WITH_INFO) {
 130       printf("Driver reported the following diagnostics\n");
 131       extract_error("SQLDriverConnect",hdbc, SQL_HANDLE_DBC);
 132     }
 133   } else {
 134     fprintf(stderr, "Failed to connect\n");
 135     extract_error("SQLDriverConnect", hdbc, SQL_HANDLE_DBC);
 136   }
 137   checkrc (rc, __LINE__);
 138   rc = SQLSetConnectOption (hdbc, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF);
 139   checkrc (rc, __LINE__);
 140   rc = SQLAllocHandle (SQL_HANDLE_STMT, hdbc, &hstmt);
 141   checkrc (rc, __LINE__);
 142
 143
 144   iHolder = 0;
 145   strcpy (sData, "0123456789012345678901234567890123456789");
 146   rc = SQLPrepare (hstmt, (unsigned char *) "INSERT INTO t1 VALUES (?, ?)",  SQL_NTS);
 147
 148
 149   rc = SQLBindParameter (hstmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER,
 150                          0, 0, &iHolder, 0, NULL);
 151   checkrc (rc, __LINE__);
 152   SQLINTEGER sLen = SQL_NTS;
 153   rc = SQLBindParameter (hstmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR,
 154                          196, 0, (void *) sHolder, 0, &sLen);
 155   checkrc (rc, __LINE__);
 156   int i, j, k;
 157   int tCount;
 158
 159   timer.reset ();
 160   int tryno=2;
 161   /* Run 1per Test */
 162   for (i = 0; i < ITERATION; i++)
 163     {
 164           tryno=2;
 165           timer.start ();
 166           iHolder = ITERATION*thno +i ;
 167           strcpy (sHolder, sData);
 168           rc = SQLExecute (hstmt);
 169           while(rc!=0 && tryno!=0)
 170           {
 171              rc = SQLExecute (hstmt);
 172              tryno--;
 173           }
 174           if( 0==tryno ) { printf("BREAK IN INSERT THREAD NO %d\n",thno); break;}
 175           rc = SQLTransact (henv, hdbc, SQL_COMMIT);
 176           checkrc (rc, __LINE__);
 177           timer.stop ();
 178     }
 179
 180   printf("Thread No %d\t No Of Record Insert %d\n",thno,i);
 181   rc = SQLEndTran(SQL_HANDLE_DBC, hdbc, SQL_COMMIT );
 182   checkrc (rc, __LINE__);
 183
 184   rc = SQLFreeHandle (SQL_HANDLE_STMT, hstmt);
 185   checkrc (rc, __LINE__);
 186   rc = SQLDisconnect (hdbc);
 187   checkrc (rc, __LINE__);
 188   rc = SQLFreeHandle (SQL_HANDLE_DBC, hdbc);
 189   checkrc (rc, __LINE__);
 190   rc = SQLFreeHandle (SQL_HANDLE_ENV, henv);
 191   checkrc (rc, __LINE__);
 192
 193   return NULL;
 194
 195 }
 196
 197 void * runReadTest (void *massage)
 198 {
 199   int iHolder;
 200   char sHolder[200];
 201   char sData[200];
 202   int thno;
 203   thno =*(int*)massage;
 204
 205   int tempTermVar = 0;
 206   int tempTermVal = 0;
 207   int rc;
 208   char *dsn;
 209   SQLHENV henv;
 210   SQLHDBC hdbc;
 211   SQLHSTMT hstmt;
 212   dsn = (char *) "DSN=test;";
 213
 214   rc = SQLAllocHandle (SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
 215   checkrc (rc, __LINE__);
 216   SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0);
 217
 218   rc = SQLAllocHandle (SQL_HANDLE_DBC, henv, &(hdbc));
 219   checkrc (rc, __LINE__);
 220   rc = SQLConnect (hdbc,
 221                    (SQLCHAR *) dsn, SQL_NTS,
 222                    (SQLCHAR *) "root",
 223                    (SQLSMALLINT) strlen ("root"),
 224                    (SQLCHAR *) "manager",
 225                    (SQLSMALLINT) strlen (""));
 226
 227   SQLCHAR outstr[1024];
 228   SQLSMALLINT outstrlen;
 229   if (SQL_SUCCEEDED(rc)) {
 230     //printf("Connected\n");
 231     if (rc == SQL_SUCCESS_WITH_INFO) {
 232       printf("Driver reported the following diagnostics\n");
 233       extract_error("SQLDriverConnect",hdbc, SQL_HANDLE_DBC);
 234     }
 235   } else {
 236     fprintf(stderr, "Failed to connect\n");
 237     extract_error("SQLDriverConnect", hdbc, SQL_HANDLE_DBC);
 238   }
 239   checkrc (rc, __LINE__);
 240   rc = SQLSetConnectOption (hdbc, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF);
 241   checkrc (rc, __LINE__);
 242   rc = SQLAllocHandle (SQL_HANDLE_STMT, hdbc, &(hstmt));
 243   checkrc (rc, __LINE__);
 244
 245   /* Set read-only transaction type */
 246   readOnlyTrans (hdbc);
 247   rc = SQLPrepare (hstmt, (unsigned char *)
 248                    "SELECT f1, f2 FROM t1 where f1 = ?", SQL_NTS);
 249   checkrc (rc, __LINE__);
 250   long sz = 0;
 251   rc = SQLBindParameter (hstmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER,
 252                          0, 0, &tempTermVar, 0, NULL);
 253   checkrc (rc, __LINE__);
 254   rc = SQLBindCol (hstmt, 1, SQL_INTEGER, &iHolder, 0, NULL);
 255   checkrc (rc, __LINE__);
 256   rc = SQLBindCol (hstmt, 2, SQL_C_CHAR, sHolder, sizeof (sHolder), NULL);
 257   checkrc (rc, __LINE__);
 258   iHolder = 0;
 259   strcpy (sData, "0123456789012345678901234567890123456789");
 260
 261   int i, j, k;
 262   int tCount;
 263
 264   timer.reset ();
 265   int tryno=2;
 266   int count=0;
 267   /* Run 1per Test */
 268   for (i = 0; i < ITERATION; i++)
 269     {
 270           timer.start ();
 271           tempTermVar = ITERATION*thno +i ;
 272           rc = SQLExecute (hstmt);
 273           while(rc!=0 && tryno!=0)
 274           {
 275             rc = SQLExecute (hstmt);
 276             tryno--;
 277           }
 278           if(0==tryno) {printf("BREAK IN SELECT THREAD NO %d\n",thno); break;}
 279           if(SQL_SUCCEEDED(rc = SQLFetch(hstmt)))
 280           {
 281              count++;
 282           }
 283           strcpy (sData, sHolder);
 284           rc = SQLCloseCursor (hstmt);
 285           checkrc (rc, __LINE__);
 286           rc = SQLTransact (henv, hdbc, SQL_COMMIT);
 287           checkrc (rc, __LINE__);
 288           timer.stop ();
 289     }
 290     printf("Thread No %d\t No Of Record Select %d\n",thno,count);
 291   /* Set read-write transaction type */
 292   rc = SQLEndTran(SQL_HANDLE_DBC, hdbc, SQL_COMMIT );
 293   checkrc (rc, __LINE__);
 294
 295   rc = SQLFreeHandle (SQL_HANDLE_STMT, hstmt);
 296   checkrc (rc, __LINE__);
 297   rc = SQLDisconnect (hdbc);
 298   checkrc (rc, __LINE__);
 299   rc = SQLFreeHandle (SQL_HANDLE_DBC, hdbc);
 300   checkrc (rc, __LINE__);
 301   rc = SQLFreeHandle (SQL_HANDLE_ENV, henv);
 302   checkrc (rc, __LINE__);
 303
 304   return NULL;
 305 }
 306
 307 void *runUpdateTest (void *massage)
 308 {
 309   int thno;
 310   thno =*(int*)massage;
 311
 312   int rc;
 313   int iHolder;
 314   char sHolder[200];
 315   char sData[200];
 316   char *dsn;
 317   SQLHENV henv;
 318   SQLHDBC hdbc;
 319   SQLHSTMT hstmt;
 320   dsn = (char *) "DSN=test;";
 321
 322   rc = SQLAllocHandle (SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
 323   checkrc (rc, __LINE__);
 324   SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0);
 325
 326   rc = SQLAllocHandle (SQL_HANDLE_DBC, henv, &(hdbc));
 327   checkrc (rc, __LINE__);
 328   rc = SQLConnect (hdbc,
 329                    (SQLCHAR *) dsn, SQL_NTS,
 330                    (SQLCHAR *) "root",
 331                    (SQLSMALLINT) strlen ("root"),
 332                    (SQLCHAR *) "manager",
 333                    (SQLSMALLINT) strlen (""));
 334
 335   SQLCHAR outstr[1024];
 336   SQLSMALLINT outstrlen;
 337   if (SQL_SUCCEEDED(rc)) {
 338    // printf("Connected\n");
 339     if (rc == SQL_SUCCESS_WITH_INFO) {
 340       printf("Driver reported the following diagnostics\n");
 341       extract_error("SQLDriverConnect",hdbc, SQL_HANDLE_DBC);
 342     }
 343   } else {
 344     fprintf(stderr, "Failed to connect\n");
 345     extract_error("SQLDriverConnect", hdbc, SQL_HANDLE_DBC);
 346   }
 347   checkrc (rc, __LINE__);
 348   rc = SQLSetConnectOption (hdbc, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF);
 349   checkrc (rc, __LINE__);
 350   rc = SQLAllocHandle (SQL_HANDLE_STMT, hdbc, &(hstmt));
 351   checkrc (rc, __LINE__);
 352
 353   rc = SQLPrepare (hstmt,
 354                    (unsigned char *) "UPDATE t1 SET f2 = ? WHERE f1 = ?",
 355                    SQL_NTS);
 356   checkrc (rc, __LINE__);
 357   SQLINTEGER sLen = SQL_NTS;
 358   rc = SQLBindParameter (hstmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR,
 359                          196, 0, (void *) sHolder, 0, &sLen);
 360   checkrc (rc, __LINE__);
 361   rc = SQLBindParameter (hstmt, 2, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER,
 362                          0, 0, &iHolder, 0, NULL);
 363   checkrc (rc, __LINE__);
 364   iHolder = 0;
 365   strcpy (sData, "9876543210987654321098765432109876543210");
 366
 367   int i, j, k;
 368   int tCount;
 369
 370   timer.reset ();
 371   int tryno=2;
 372   for (i = 0; i < ITERATION; i++)
 373     {
 374           timer.start ();
 375           iHolder = ITERATION*thno+1;
 376           strcpy (sHolder, sData);
 377           rc = SQLExecute (hstmt);
 378           while(rc!=0 && tryno!=0)
 379           {
 380             rc = SQLExecute (hstmt);
 381             tryno--;
 382           }
 383           if(0==tryno) {printf("BREAK IN UPDATE THREAD NO %d\n",thno); break;}
 384           checkrc (rc, __LINE__);
 385           rc = SQLTransact (henv, hdbc, SQL_COMMIT);
 386           checkrc (rc, __LINE__);
 387           timer.stop ();
 388     }
 389     printf("Thread No %d\t No Of Record Update %d\n",thno,i);
 390  rc = SQLEndTran(SQL_HANDLE_DBC, hdbc, SQL_COMMIT );
 391   checkrc (rc, __LINE__);
 392
 393   rc = SQLFreeHandle (SQL_HANDLE_STMT, hstmt);
 394   checkrc (rc, __LINE__);
 395   rc = SQLDisconnect (hdbc);
 396   checkrc (rc, __LINE__);
 397   rc = SQLFreeHandle (SQL_HANDLE_DBC, hdbc);
 398   checkrc (rc, __LINE__);
 399   rc = SQLFreeHandle (SQL_HANDLE_ENV, henv);
 400   checkrc (rc, __LINE__);
 401
 402   return NULL;
 403 }
 404
 405 void *runDeleteTest (void *massage)
 406 {
 407   int thno;
 408   thno =*(int*)massage;
 409   int rc;
 410   int iHolder;
 411   char *dsn;
 412   SQLHENV henv;
 413   SQLHDBC hdbc;
 414   SQLHSTMT hstmt;
 415   dsn = (char *) "DSN=test;";
 416
 417   rc = SQLAllocHandle (SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
 418   checkrc (rc, __LINE__);
 419   SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0);
 420
 421   rc = SQLAllocHandle (SQL_HANDLE_DBC, henv, &(hdbc));
 422   checkrc (rc, __LINE__);
 423   rc = SQLConnect (hdbc,
 424                    (SQLCHAR *) dsn, SQL_NTS,
 425                    (SQLCHAR *) "root",
 426                    (SQLSMALLINT) strlen ("root"),
 427                    (SQLCHAR *) "manager",
 428                    (SQLSMALLINT) strlen (""));
 429
 430   SQLCHAR outstr[1024];
 431   SQLSMALLINT outstrlen;
 432   if (SQL_SUCCEEDED(rc)) {
 433    // printf("Connected\n");
 434     if (rc == SQL_SUCCESS_WITH_INFO) {
 435       printf("Driver reported the following diagnostics\n");
 436       extract_error("SQLDriverConnect",hdbc, SQL_HANDLE_DBC);
 437     }
 438   } else {
 439     fprintf(stderr, "Failed to connect\n");
 440     extract_error("SQLDriverConnect", hdbc, SQL_HANDLE_DBC);
 441   }
 442   checkrc (rc, __LINE__);
 443   rc = SQLSetConnectOption (hdbc, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF);
 444   checkrc (rc, __LINE__);
 445   rc = SQLAllocHandle (SQL_HANDLE_STMT, hdbc, &(hstmt));
 446   checkrc (rc, __LINE__);
 447
 448   rc = SQLPrepare (hstmt, (unsigned char *)
 449                    "DELETE FROM t1 WHERE f1 = ?", SQL_NTS);
 450   checkrc (rc, __LINE__);
 451   rc = SQLBindParameter (hstmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER,
 452                          0, 0, &iHolder, 0, NULL);
 453   checkrc (rc, __LINE__);
 454   iHolder = 0;
 455   int i, j, k;
 456   int tCount;
 457   timer.reset ();
 458   int tryno=2;
 459   for (i = 0; i < ITERATION; i++)
 460     {
 461           timer.start ();
 462           iHolder = ITERATION*thno+i ;
 463           rc = SQLExecute (hstmt);
 464           while(rc!=0 && tryno!=0)
 465           {
 466             rc = SQLExecute (hstmt);
 467             tryno--;
 468           }
 469           if(0==tryno) {printf("BREAK IN DELETE THREAD NO %d\n",thno); break;}
 470           rc = SQLTransact (henv, hdbc, SQL_COMMIT);
 471           checkrc (rc, __LINE__);
 472           timer.stop ();
 473     }
 474     printf("Thread No %d\t No Of Record Delete %d\n",thno,i);
 475   //printf ("Delete: 1 %lld %lld %lld\n", timer.minc (), timer.maxc (), timer.avg ());
 476   rc = SQLEndTran(SQL_HANDLE_DBC, hdbc, SQL_COMMIT );
 477   checkrc (rc, __LINE__);
 478
 479   rc = SQLFreeHandle (SQL_HANDLE_STMT, hstmt);
 480   checkrc (rc, __LINE__);
 481   rc = SQLDisconnect (hdbc);
 482   checkrc (rc, __LINE__);
 483   rc = SQLFreeHandle (SQL_HANDLE_DBC, hdbc);
 484   checkrc (rc, __LINE__);
 485   rc = SQLFreeHandle (SQL_HANDLE_ENV, henv);
 486   checkrc (rc, __LINE__);
 487
 488   return NULL;
 489
 490 }
 491
 492
 493 int main (int ac, char **av)
 494 {
 495   int rc;
 496   char *dsn;
 497   SQLHENV henv;
 498   SQLHDBC hdbc;
 499   SQLHSTMT hstmt;
 500   dsn = (char *) "DSN=test;";
 501
 502   rc = SQLAllocHandle (SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
 503   checkrc (rc, __LINE__);
 504   SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0);
 505
 506   rc = SQLAllocHandle (SQL_HANDLE_DBC, henv, &(hdbc));
 507   checkrc (rc, __LINE__);
 508   rc = SQLConnect (hdbc,
 509                    (SQLCHAR *) dsn, SQL_NTS,
 510                    (SQLCHAR *) "root",
 511                    (SQLSMALLINT) strlen ("root"),
 512                    (SQLCHAR *) "manager",
 513                    (SQLSMALLINT) strlen (""));
 514
 515   SQLCHAR outstr[1024];
 516   SQLSMALLINT outstrlen;
 517   if (SQL_SUCCEEDED(rc)) {
 518     //printf("Connected\n");
 519     if (rc == SQL_SUCCESS_WITH_INFO) {
 520       printf("Driver reported the following diagnostics\n");
 521       extract_error("SQLDriverConnect",hdbc, SQL_HANDLE_DBC);
 522     }
 523   } else {
 524     fprintf(stderr, "Failed to connect\n");
 525     extract_error("SQLDriverConnect", hdbc, SQL_HANDLE_DBC);
 526   }
 527   checkrc (rc, __LINE__);
 528   rc = SQLSetConnectOption (hdbc, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF);
 529   checkrc (rc, __LINE__);
 530   rc = SQLAllocHandle (SQL_HANDLE_STMT, hdbc, &(hstmt));
 531   checkrc (rc, __LINE__);
 532   rc = SQLExecDirect(hstmt, (SQLCHAR*) "CREATE TABLE t1 (f1 INTEGER, f2 char(196));", SQL_NTS );
 533   checkrc (rc, __LINE__);
 534   printf("t1 Table Created\n");
 535 #ifdef HASH
 536   rc = SQLExecDirect(hstmt, (SQLCHAR*) "CREATE INDEX idx1 on t1(f1) hash;", SQL_NTS );
 537   checkrc (rc, __LINE__);
 538   printf("Hash Index Created\n");
 539 #endif
 540 #ifdef TREE
 541   rc = SQLExecDirect(hstmt, (SQLCHAR*) "CREATE INDEX idx1 on t1(f1) tree;", SQL_NTS );
 542   checkrc (rc, __LINE__);
 543   printf("Tree Index Created\n");
 544 #endif
 545   pthread_t thr[THREADS];
 546   int message[THREADS];
 547   int status;
 548   printf("Insert Operartion \n");
 549   for (int i=0; i <THREADS; i++)
 550   {
 551         message[i] = i;
 552         pthread_create (&thr[i], NULL, &runInsertTest, (void *) &message[i]);
 553   }
 554   for (int i=0; i <THREADS; i++) {
 555        pthread_join(thr[i], (void**)&status);
 556   }
 557   printf("Select Operartion \n");
 558   for (int i=0; i <THREADS; i++)
 559   {
 560         message[i] = i;
 561         pthread_create (&thr[i], NULL, &runReadTest, (void *) &message[i]);
 562   }
 563   for (int i=0; i <THREADS; i++) {
 564        pthread_join(thr[i], (void**)&status);
 565   }
 566   printf("Update Operartion \n");
 567   for (int i=0; i <THREADS; i++)
 568   {
 569         message[i] = i;
 570         pthread_create (&thr[i], NULL, &runUpdateTest, (void *) &message[i]);
 571   }
 572   for (int i=0; i <THREADS; i++) {
 573        pthread_join(thr[i], (void**)&status);
 574   }
 575   printf("Delete Operartion \n");
 576   for (int i=0; i <THREADS; i++)
 577   {
 578         message[i] = i;
 579         pthread_create (&thr[i], NULL, &runDeleteTest, (void *) &message[i]);
 580   }
 581   for (int i=0; i <THREADS; i++) {
 582        pthread_join(thr[i], (void**)&status);
 583   }
 584
 585   rc = SQLExecDirect(hstmt, (SQLCHAR*) "DROP TABLE t1;", SQL_NTS );
 586   checkrc (rc, __LINE__);
 587   printf("t1 Table Droped\n");
 588   rc = SQLEndTran(SQL_HANDLE_DBC, hdbc, SQL_COMMIT );
 589   checkrc (rc, __LINE__);
 590
 591   rc = SQLFreeHandle (SQL_HANDLE_STMT, hstmt);
 592   checkrc (rc, __LINE__);
 593   rc = SQLDisconnect (hdbc);
 594   checkrc (rc, __LINE__);
 595   rc = SQLFreeHandle (SQL_HANDLE_DBC, hdbc);
 596   checkrc (rc, __LINE__);
 597   rc = SQLFreeHandle (SQL_HANDLE_ENV, henv);
 598   checkrc (rc, __LINE__);
 599   exit (0);
 600 }