mariadb/storage/ndb/test/odbc/SQL99_test/SQL99_test.cpp

/* Copyright (C) 2003 MySQL AB

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

// ODBC.cpp : Defines the entry point for the console application.
//

#include "SQL99_test.h"
#include <iostream> // Loose later

using namespace std; //

#define MAXCOL			64
#define DEFCOL			4

#define MAXROW			64
#define DEFROW			8

#define MAXTHREADS		24
#define DEFTHREADS		2

#define MAXTABLES		16
#define DEFTABLES		2

#define MAXLOOPS		100000
#define DEFLOOPS		4

#define UPDATE_VALUE	7

#define PKSIZE 2


static int nNoOfThreads = 1 ;
static int nNoOfCol = 4 ;
static int nNoOfRows = 2 ;
static int nNoOfLoops = 0 ;
static int nNoOfTables = 2 ;
static int nAPI = 0 ;
static int tAttributeSize = sizeof(char) ;
static attr_type AttributeType = T_CHAR ;
static int nAggregate = 0 ;
static int nArithmetic = 0 ;
static int nPrint = 0 ;
static int nColList = 0 ;
static char szColNames[MAXCOL*MAX_COL_NAME] = { 0 } ;
int createTables(char* szTableName, int nTables) ;


/*************************************************
Function: main - the entry point
*************************************************/
int main(int argc, char* argv[]){	

	int nRetrunValue = NDBT_FAILED ;
	SQLRETURN rc = SQL_ERROR ;
	double dResultA = 0 ;
    double dResultB = 0 ;
    double dInput = 0 ;
    int x = 0, y = 0 ;
    int* pIntRefBuffer = NULL ;
    float* pFloatRefBuffer = NULL ;
    double*	pDoubleRefBuffer = NULL ;
    char* pCharRefBuffer = NULL ;
	char szColBuffer[MAX_COL_NAME] = { 0 } ;


    ParseArguments(argc, (const char**)argv) ;

    PARAMS* pparams = (PARAMS*)malloc(sizeof(PARAMS)*nNoOfThreads) ;
    memset(pparams, 0, (sizeof(PARAMS)*nNoOfThreads)) ;

    char* szTableNames = (char*)malloc(sizeof(char)*nNoOfTables*MAX_TABLE_NAME) ;
    memset(szTableNames, 0, sizeof(char)*nNoOfTables*MAX_TABLE_NAME) ;

	UintPtr pThreadHandles[MAXTHREADS] = { NULL } ;

    AssignTableNames(szTableNames, nNoOfTables) ;

	if(nAPI){
		if(0 != createTables(szTableNames, nNoOfTables)){
			printf("Failed to create tables through NDB API; quitting...\n") ;
			NDBT_ProgramExit(NDBT_FAILED) ;
			return NDBT_FAILED ;
		}
	}else{
	
		//CreateDemoTables(szTableNames, nNoOfTables, DROP) ;
		rc = CreateDemoTables(szTableNames, nNoOfTables, CREATE) ;
		if(!(SQL_SUCCESS == rc || SQL_SUCCESS_WITH_INFO == rc)){
			printf("Failed to create tables, quiting now.\n") ;
			NDBT_ProgramExit(NDBT_FAILED) ;
			return NDBT_FAILED ;
		}
	}

	// Store column names in the buffer for use in some stmts
	int k = 0 ;
	for(;;){
		memset((char*)szColBuffer, 0, strlen(szColBuffer)) ;
		sprintf((char*)szColBuffer, "COL%d", k) ;
        strcat((char*)szColNames, (char*)szColBuffer) ;
        ++k ;
		if( k == nNoOfCol ){
			break ;
		}	
		strcat((char*)szColNames, ", ") ;
	} // for


    switch(AttributeType){
        case T_INT:
            pIntRefBuffer = (int*)malloc(sizeof(int)*nNoOfRows*nNoOfCol*nNoOfThreads) ;
            memset(pIntRefBuffer, 0, sizeof(int)*nNoOfRows*nNoOfCol*nNoOfThreads) ;
            AssignRefNumValues(pIntRefBuffer, T_INT, nPrint) ;
            StartThreads(pparams, (void*)pIntRefBuffer, nNoOfTables, szTableNames, AttributeType, pThreadHandles) ;
            break ;
        case T_FLOAT:
            pFloatRefBuffer = (float*)malloc(sizeof(float)*nNoOfRows*nNoOfCol*nNoOfThreads) ;
            memset(pFloatRefBuffer, 0, sizeof(float)*nNoOfRows*nNoOfCol*nNoOfThreads) ;
            AssignRefNumValues(pFloatRefBuffer, T_FLOAT, nPrint) ;
            StartThreads(pparams, (void*)pFloatRefBuffer, nNoOfTables, szTableNames, AttributeType, pThreadHandles) ;
            break ;
/*        case T_DOUBLE:
            pDoubleRefBuffer = (double*)malloc(sizeof(double)*nNoOfRows*nNoOfCol*nNoOfThreads) ;
            memset(pDoubleRefBuffer, 0, sizeof(double)*nNoOfRows*nNoOfCol*nNoOfThreads) ;
            AssignRefNumValues(pDoubleRefBuffer, T_DOUBLE, 0) ;
            StartThreads(pparams, (void*)pDoubleRefBuffer, nNoOfTables, szTableNames, AttributeType, pThreadHandles) ;
            break ;
*/
        case T_CHAR:
            pCharRefBuffer = (char*)malloc(sizeof(char)*nNoOfRows*nNoOfCol*nNoOfThreads*MAX_CHAR_ATTR_LEN) ;
            memset(pCharRefBuffer, 0, sizeof(char)*nNoOfRows*nNoOfCol*nNoOfThreads*MAX_CHAR_ATTR_LEN) ;
            AssignRefCharValues(pCharRefBuffer, nPrint ) ;
            StartThreads(pparams, (void*)pCharRefBuffer, nNoOfTables, szTableNames, AttributeType, pThreadHandles) ;
            break ;
        default:
            break ;
        }

	NdbThread_SetConcurrencyLevel(nNoOfThreads + 2) ;


	printf("\nPerforming inserts...") ;
	SetThreadOperationType(pparams, T_INSERT) ;
	if(0 < WaitForThreads(pparams)){
		printf("\t\t%d thread(s) failed\n") ;
	}else{
		printf("\t\tdone\n") ;
	}
	printf("----------------------\n\n") ;
	PrintAll(szTableNames, nNoOfTables, AttributeType) ;

	printf("\nVerifying inserts...") ;
	SetThreadOperationType(pparams, T_READ_VERIFY) ;
	if(0 < WaitForThreads(pparams)){
		printf("\t\t%d thread(s) failed\n") ;
	}else{
		printf("\t\tdone\n") ;
	}
	printf("----------------------\n\n") ;

	printf("\nPerforming updates...") ;
	SetThreadOperationType(pparams, T_UPDATE) ;
	if(0 < WaitForThreads(pparams)){
		printf("\t\t%d thread(s) failed\n") ;
	}else{
		printf("\t\tdone\n") ;
	}
	printf("----------------------\n\n") ;
	//PrintAll(szTableNames, nNoOfTables, AttributeType) ;

	printf("\nVerifying updates...") ;
	SetThreadOperationType(pparams, T_READ_VERIFY) ;
	if(0 < WaitForThreads(pparams)){
		printf("\t\t%d thread(s) failed\n") ;
	}else{
		printf("\t\tdone\n") ;
	}
	printf("----------------------\n\n") ;

	printf("\nPerforming reads...") ;
	SetThreadOperationType(pparams, T_READ) ;
	if(0 < WaitForThreads(pparams)){
		printf("\t\t%d thread(s) failed\n") ;
	}else{
		printf("\t\tdone\n") ;
	}
	printf("----------------------\n\n") ;
	PrintAll(szTableNames, nNoOfTables, AttributeType) ;


	if(T_CHAR != AttributeType && nAggregate){
		printf("\nTesting aggregate functions for each table\n\n") ;
		printf("FN\tCOLUMN\tVALUE\t\t\tTOTAL ROWS WHERE\n\t\t\t\t\tVALUE(S) > VALUE\n--------------------------------------------------------\n\n") ;

		for(y = 0 ; y < nNoOfTables ; ++y){
			for(x = 0; x < nNoOfCol ; ++x){
				dResultA = dResultB = 0 ;
				AggregateFn(FN_MIN, (char*)(szTableNames + MAX_TABLE_NAME*y), x, NULL, &dResultA, AttributeType) ;
				AggregateFn(FN_COUNT, (char*)(szTableNames + MAX_TABLE_NAME*y) , x, &dResultA, &dResultB, AttributeType) ;
				ATTR_TYPE_SWITCH_AGR("MIN", x, dResultA, dResultB, AttributeType) ;	
				}
			}

			for(y = 0; y < nNoOfTables ; ++y){ 
				for(x = 0; x < nNoOfCol ; ++x){
					dResultA = dResultB = 0 ;
					AggregateFn(FN_MAX, (char*)(szTableNames + MAX_TABLE_NAME*y), x, NULL, &dResultA, AttributeType) ;
					AggregateFn(FN_COUNT, (char*)(szTableNames + MAX_TABLE_NAME*y), x, &dResultA, &dResultB, AttributeType) ;
					ATTR_TYPE_SWITCH_AGR("MAX", x, dResultA, dResultB, AttributeType) ;
					}
				}

			for(y = 0 ; y < nNoOfTables ; ++y){
				for(x = 0; x < nNoOfCol ; ++x){
					dResultA = dResultB = 0 ;
					AggregateFn(FN_AVG, (char*)(szTableNames + MAX_TABLE_NAME*y), x, NULL, &dResultA, AttributeType) ;
					AggregateFn(FN_COUNT, (char*)(szTableNames + MAX_TABLE_NAME*y), x, &dResultA, &dResultB, AttributeType) ;
					ATTR_TYPE_SWITCH_AGR("AVG", x, dResultA, dResultB, AttributeType)
					}
			}

			printf("--------------------------------------------------------\n\n") ;
	}

	if(T_CHAR != AttributeType && nArithmetic){

	float nVal = (rand() % 10) /1.82342 ;

		for(int h = 0 ; h < nNoOfTables ; ++h){

			printf("\nTesting arithmetic operators\nfor each column in %s:\n----------------------\n", (char*)(szTableNames + MAX_TABLE_NAME*sizeof(char)*h) ) ;

			printf("\nOperator [ * ]... \t\t") ;
			ArithOp((char*)(szTableNames + MAX_TABLE_NAME*sizeof(char)*h), nNoOfCol, &nVal, AttributeType, MULTI) ;
			printf("done\n") ;

			printf("\nOperator [ / ]... \t\t") ;
			ArithOp((char*)(szTableNames + MAX_TABLE_NAME*sizeof(char)*h), nNoOfCol, &nVal, AttributeType, DIVIDE) ;
			printf("done\n") ;

			printf("\nOperator [ + ]... \t\t") ;
			ArithOp((char*)(szTableNames + MAX_TABLE_NAME*sizeof(char)*h), nNoOfCol, &nVal, AttributeType, PLUS) ;
			printf("done\n") ;

			printf("\nOperator [ - ]... \t\t") ;
			ArithOp((char*)(szTableNames + MAX_TABLE_NAME*sizeof(char)*h), nNoOfCol, &nVal, AttributeType, MINUS) ;
			printf("done\n\n") ;
			/*	
			printf("\nOperator [ % ]... \t\t") ;
			ArithOp((char*)szTableNames, nNoOfCol, &nVal, AttributeType, MODULO) ;
			printf("done\n\n") ;
			*/	
		}
	}
/*
	printf("\nPerforming deletes...") ;
	SetThreadOperationType(pparams, T_DELETE) ;
	if(0 < WaitForThreads(pparams)){
		printf("\t\t%d thread(s) failed\n") ;
	}else{
		printf("\t\tdone\n") ;
	}
	printf("----------------------\n\n") ;

	printf("\nVerifying deletes...") ;
	SetThreadOperationType(pparams, T_DELETE_VERIFY) ;
	if(0 < WaitForThreads(pparams)){
		printf("\t\t%d thread(s) failed\n") ;
	}else{
		printf("\t\tdone\n") ;
	}
	printf("----------------------\n\n") ;
*/
	StopThreads(pparams, pThreadHandles) ;

	//PrintAll(szTableNames, nNoOfTables, AttributeType) ;

	//CreateDemoTables(szTableNames, nNoOfTables, DROP) ;

	free((void*)szTableNames) ;
	free((void*)pparams) ;
	free((void*)pIntRefBuffer) ;
	free((void*)pFloatRefBuffer) ;
	free((void*)pDoubleRefBuffer) ;
	free((void*)pCharRefBuffer) ;

	return 0;
}



/**************************************************
Function: ParseArguments
***************************************************/
void ParseArguments(int argc, const char** argv){

    int i = 1;

    while (argc > 1){

        if (strcmp(argv[i], "-t") == 0)
            {
            nNoOfThreads = atoi(argv[i+1]);
            if ((nNoOfThreads < 1) || (nNoOfThreads > MAXTHREADS))
                nNoOfThreads = DEFTHREADS ;
            }
        else if (strcmp(argv[i], "-c") == 0)
            {
            nNoOfCol = atoi(argv[i+1]);
            if ((nNoOfCol < 2) || (nNoOfCol > MAXCOL))
                nNoOfCol = DEFCOL ;
            }
        else if (strcmp(argv[i], "-l") == 0)
            {
            nNoOfLoops = atoi(argv[i+1]);
            if ((nNoOfLoops < 0) || (nNoOfLoops > MAXLOOPS))
                nNoOfLoops = DEFLOOPS ;
            }
        else if (strcmp(argv[i], "-r") == 0)
            {
            nNoOfRows = atoi(argv[i+1]);;
            if ((nNoOfRows < 0) || (nNoOfRows > MAXROW))
                nNoOfRows = DEFROW ;
            }
		else if (strcmp(argv[i], "-m") == 0)
            {
            nArithmetic = 1 ;
			argc++ ;
			i-- ;
            }
		else if (strcmp(argv[i], "-g") == 0)
            {
            nAggregate = 1 ;
			argc++ ;
			i-- ;
            }
		else if (strcmp(argv[i], "-n") == 0)
            {
			nAPI = 1 ;
			argc++ ;
			i-- ;
            }
		else if (strcmp(argv[i], "-v") == 0)
            {
			nPrint = 1 ;
			argc++ ;
			i-- ;
            }
        else if (strcmp(argv[i], "-a") == 0)
            {
            if(strcmp(argv[i+1], "int") == 0){
                AttributeType = T_INT ;
				tAttributeSize = 32 ;
                }else if(strcmp(argv[i+1], "float") == 0){
                    AttributeType = T_FLOAT ;
					tAttributeSize = 64 ;
                    }else if(strcmp(argv[i+1], "char") == 0){
                        AttributeType = T_CHAR ;
                        }
            }
        else
            {
            cout << "Arguments:\n";
			cout << "-n Create tables using NDB API (vs ODBC by default)" << endl;
            cout << "-t Number of threads; maximum 24, default 2\n" << endl;
            cout << "-c Number of columns per table; maximum 64, default 4\n" << endl;
            cout << "-r Number of rows; maximum 64, default 8\n" << endl;
            cout << "-a Type of attribute to use: int, double or char; default int " << endl;
            cout << "-g Test aggregate functions" << endl;
			cout << "-m Test arithmetic operators" << endl;
			cout << "-v Print executed statements" << endl;
            exit(-1);
            }

        argc -= 2 ;
        i = i + 2 ;
        }

char *szAttrType[MAX_STR_LEN] = { 0 } ;
switch(AttributeType){
        case T_INT:
            strcpy((char*)szAttrType, "Integer") ;
            break ;
        case T_FLOAT:
            strcpy((char*)szAttrType, "Float") ;
            break ;
/*        case T_DOUBLE:
            strcpy((char*)szAttrType, "Double") ;
            break ;
*/
        case T_CHAR:
            strcpy((char*)szAttrType, "Character") ;
            break ;
        default:
            strcpy((char*)szAttrType, "Not defined") ;
            break ;
    }


printf("\n\nCurrent parameters: %d thread(s), %d tables, %d rows, %d colums, attribute type: %s\n\n", nNoOfThreads, nNoOfTables, nNoOfRows, nNoOfCol, szAttrType) ;
    }




/*************************************************
Function: ThreadFnInt - thread function
for int attributes
*************************************************/
void* ThreadFnInt(void* pparams){

    SQLRETURN retcode = SQL_ERROR ;
    SQLCHAR	szStmtBuffer[MAX_SQL_STMT] = { 0 } ;
    SQLCHAR szValueBuffer[MAX_VALUE_LEN] = { 0 } ;
    SQLCHAR szAuxBuffer[MAX_STR_LEN] = { 0 } ;
    SQLCHAR szColBuffer[MAX_COL_NAME] = { 0 } ;
    SQLINTEGER cbInt = 0 ;
    ODBC_HANDLES stHandles ;
    memset(&stHandles, 0, sizeof(ODBC_HANDLES)) ;

    int r = 0, j = 0 ;
    //Get thread parameters 	
    PARAMS* p = (PARAMS*)pparams ;
    int* pRef = (int*)p->pThreadRef ;

    int* pBindBuffer = (int*)malloc(sizeof(int)*nNoOfCol) ;

    //printf("Thread #%d\n", p->nThreadID) ;

    retcode = GetHandles(&stHandles, GET, 0) ;
	
	if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode ) {
		p->report_status = S_STARTED ;
	}else{
		printf("Thread #%d failed to allocate handles, exiting now.\n", p->nThreadID) ;
		free((void*)pBindBuffer) ;
		p->nError = 1 ;
		p->report_status = S_EXIT ;
		return 0 ;
	}
    
	//p->report_status = S_STARTED ;

    //Main thread loop
    for(;;){

        while(S_IDLE == p->thread_status){
            NdbSleep_MilliSleep(1) ;
            }

    if(S_STOP == p->thread_status) {
        break ;
        }else{
            p->thread_status = S_BUSY ;
            }

    switch(p->op_type){


        /************************************** T_INSERT case **************************************/
        case T_INSERT:

            for(r = 0 ; r < nNoOfRows ; ++r){

				if(!nColList){
					sprintf((char*)szStmtBuffer, "INSERT INTO %s VALUES(", p->szTableName) ; 
				}else{
					sprintf((char*)szStmtBuffer, "INSERT INTO %s (%s) VALUES(", p->szTableName, szColNames) ;
				}

                //sprintf((char*)szStmtBuffer, "INSERT INTO %s VALUES(", p->szTableName) ; 

                for(j = 0 ;;){
                    sprintf((char*)szValueBuffer,"%d", pRef[nNoOfCol*r + j]) ;
                    strncat((char*)szStmtBuffer, (char*)szValueBuffer, strlen((char*)szValueBuffer)) ;
                    ++j ;
                    if(nNoOfCol == j) break ;
                    strcat((char*)szStmtBuffer, ", ") ;
                    }
            strcat((char*)szStmtBuffer, ")") ;
			if(nPrint) printf("\n> %s\n", szStmtBuffer) ;
            retcode = SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS) ;
			if(SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
			}else{
				p->nError = 1 ;
				printf("INSERT in thread #%d failed\n", p->nThreadID) ;
				HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
			}
			}
        break ;


        /************************************** T_READ case **************************************/
        case T_READ:

            for(r = 0 ; r < nNoOfRows ; r++){

                sprintf((char*)szStmtBuffer, "SELECT * FROM %s WHERE COL0 = %d", p->szTableName, pRef[nNoOfCol*r]) ;
				if(nPrint) printf("\n> %s\n", szStmtBuffer) ;
                ODBC_FN(SQLExecDirect(stHandles.hstmt, (SQLCHAR*)szStmtBuffer, SQL_NTS), retcode) ;

                for(j = 0 ; j < nNoOfCol ; ++j){
                    ODBC_FN(SQLBindCol(stHandles.hstmt, (j+1), SQL_C_SLONG, (void*)&pBindBuffer[j], sizeof(SQLINTEGER), &cbInt), retcode) ;
                    }

            for (;;) {
                retcode = SQLFetch(stHandles.hstmt);

                if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
                    for(int k = 0 ; k < nNoOfCol ; ++k){
                        if(p->nVerifyFlag){
                            if(pBindBuffer[k] != pRef[nNoOfCol*r + k])
                                printf("Expected: %d Actual: %d\n", pBindBuffer[k], pRef[nNoOfCol*r + k]) ;
                            }
                        }
                    }else if(SQL_NO_DATA == retcode){
                        break ;
                        }else{
							p->nError = 1 ;
							printf("READ in thread #%d failed\n", p->nThreadID) ;
                            HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
                            }
                    //printf("\n") ;
                }
				SQLCloseCursor(stHandles.hstmt) ;
			}
        break ;


        /************************************** T_UPDATE case **************************************/
        case T_UPDATE:
            for(r = 0 ; r < nNoOfRows ; ++r){

                sprintf((char*)szStmtBuffer, "UPDATE %s SET ", p->szTableName) ; 
                for(j = 1 ;;){
                    pRef[nNoOfCol*r + j] = pRef[nNoOfCol*r + j] + UPDATE_VALUE ;
                    sprintf((char*)szColBuffer,"COL%d = %d",  j, pRef[nNoOfCol*r + j]) ;
                    strncat((char*)szStmtBuffer, (char*)szColBuffer, strlen((char*)szColBuffer)) ;
                    ++j ;
                    if(nNoOfCol == j) break ;
                    strcat((char*)szStmtBuffer, ", ") ;
				}
				sprintf((char*)szAuxBuffer, " WHERE COL0 = %d ;", pRef[nNoOfCol*r]) ;		
				strcat((char*)szStmtBuffer, (char*)szAuxBuffer);
				if(nPrint) printf("\n> %s\n", szStmtBuffer) ;
				retcode = SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS) ;

				if(SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
				}else{
					p->nError = 1 ;
					printf("UPDATE in thread %d failed\n", p->nThreadID) ;
					HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
				}
			}
        break ;


        /************************************** T_DELETE case **************************************/
        case T_DELETE:
            for(r = 0 ; r < nNoOfRows ; ++r){
                sprintf((char*)szStmtBuffer, "DELETE * FROM %s WHERE COL0 = %d", p->szTableName, pRef[nNoOfCol*r]) ;
                if(nPrint) printf("\n> %s\n", szStmtBuffer) ;
				retcode = SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS) ;
				if(SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
				}else if( 1 == p->nVerifyFlag  && SQL_NO_DATA != retcode){
					p->nError = 1 ;
					printf("\nVerification failed: the row found\n") ;
                }else{
					p->nError = 1 ;
					printf("INSERT in thread %d failed\n", p->nThreadID) ;
					HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
				}

			}
        break ;


        /************************************** default case **************************************/
        default:
            break ;
        }//switch
p->thread_status = S_IDLE ;
        } //for

free((void*)pBindBuffer) ;
GetHandles(&stHandles, FREE, 0) ;
p->thread_status = S_EXIT ;
return 0 ;	
    };



/*************************************************
Function: ThreadFnFloat - thread function
for float attributes
*************************************************/
void* ThreadFnFloat(void* pparams){

    SQLRETURN retcode = SQL_ERROR ;
    SQLCHAR	szStmtBuffer[MAX_SQL_STMT] = { 0 } ;
    SQLCHAR szValueBuffer[MAX_VALUE_LEN] = { 0 } ;
    SQLCHAR szAuxBuffer[MAX_STR_LEN] = { 0 } ;
    SQLCHAR szColBuffer[MAX_COL_NAME] = { 0 } ;
    SQLINTEGER cbFloat = 0 ;
    ODBC_HANDLES stHandles ;
    memset(&stHandles, 0, sizeof(ODBC_HANDLES)) ;

    int r = 0, j = 0 ;
    //Get thread parameters 	
    PARAMS* p = (PARAMS*)pparams ;

    float* pRef = (float*)p->pThreadRef ;
    float* pBindBuffer = (float*)malloc(sizeof(float)*nNoOfCol) ;

    //printf("Thread #%d\n", p->nThreadID) ;

    retcode = GetHandles(&stHandles, GET, 0) ;
	
	if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode ) {
		p->report_status = S_STARTED ;
	}else{
		printf("Thread #%d failed to allocate handles, exiting now.\n", p->nThreadID) ;
		free((void*)pBindBuffer) ;
		p->nError = 1 ;
		p->report_status = S_EXIT ;
		return 0 ;
	}

    //p->report_status = S_STARTED ;

    //Main thread loop
    for(;;){

        while(S_IDLE == p->thread_status){
            NdbSleep_MilliSleep(1) ;
            }

    if(S_STOP == p->thread_status) {
        break ;
        }else{
            p->thread_status = S_BUSY ;
            }

    switch(p->op_type){


        /************************************** T_INSERT case **************************************/
        case T_INSERT:

            for(r = 0 ; r < nNoOfRows ; ++r){

				if(!nColList){
					sprintf((char*)szStmtBuffer, "INSERT INTO %s VALUES(", p->szTableName) ; 
				}else{
					sprintf((char*)szStmtBuffer, "INSERT INTO %s (%s) VALUES(", p->szTableName, szColNames) ;
				}

                //sprintf((char*)szStmtBuffer, "INSERT INTO %s VALUES(", p->szTableName) ; 

                for(j = 0 ;;){
                    sprintf((char*)szValueBuffer,"%f", pRef[nNoOfCol*r + j]) ;
                    strncat((char*)szStmtBuffer, (char*)szValueBuffer, strlen((const char*)szValueBuffer)) ;
                    ++j ;
                    if(nNoOfCol == j) break ;
                    strcat((char*)szStmtBuffer, ", ") ;
                    }
            strcat((char*)szStmtBuffer, ")") ;
			if(nPrint) printf("\n> %s\n", szStmtBuffer) ;
            retcode = SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS) ;
			if(SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
			}else{
				p->nError = 1 ;
				printf("INSERT in thread #%d failed\n", p->nThreadID) ;
				HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
			}
                }
        break ;


        /************************************** T_READ case **************************************/
        case T_READ:

            for(r = 0 ; r < nNoOfRows ; ++r){

                sprintf((char*)szStmtBuffer, "SELECT * FROM %s WHERE COL0 = %f", p->szTableName, pRef[nNoOfCol*r]) ;
				if(nPrint) printf("\n> %s\n", szStmtBuffer) ;
                ODBC_FN(SQLExecDirect(stHandles.hstmt, (SQLCHAR*)szStmtBuffer, SQL_NTS), retcode) ;

                for(j = 0 ; j < nNoOfCol ; ++j){
                    ODBC_FN(SQLBindCol(stHandles.hstmt, (j+1), SQL_C_FLOAT, (void*)&pBindBuffer[j], sizeof(SQLFLOAT), &cbFloat), retcode) ;
                    }

            for (;;) {
                retcode = SQLFetch(stHandles.hstmt);

                if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
                    for(int k = 0 ; k < nNoOfCol ; ++k){
                        if(p->nVerifyFlag){
                            if(abs(pBindBuffer[k] - pRef[nNoOfCol*r + k]) > FLTDEV )
                                printf("Expected: %f Actual: %f\n", pBindBuffer[k], pRef[nNoOfCol*r + k]) ;
                            }
                        }
                    }else if(SQL_NO_DATA == retcode){
                        break ;
					}else{
						p->nError = 1 ;
						printf("READ in thread #%d failed\n", p->nThreadID) ;
						HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
					}
                    //printf("\n") ;
                }
        SQLCloseCursor(stHandles.hstmt) ;
                }
        break ;


        /************************************** T_UPDATE case **************************************/
        case T_UPDATE:
            for(r = 0 ; r < nNoOfRows ; ++r){

                sprintf((char*)szStmtBuffer, "UPDATE %s SET ", p->szTableName) ; 
                for(j = 1 ;;){
                    pRef[nNoOfCol*r + j] = pRef[nNoOfCol*r + j] + UPDATE_VALUE ;
                    sprintf((char*)szColBuffer,"COL%d = %f",  j, pRef[nNoOfCol*r + j]) ;
                    strncat((char*)szStmtBuffer, (char*)szColBuffer, strlen((char*)szColBuffer)) ;
                    ++j ;
                    if(nNoOfCol == j) break ;
                    strcat((char*)szStmtBuffer, ", ") ;
                    }
            sprintf((char*)szAuxBuffer, " WHERE COL0 = %f ;", pRef[nNoOfCol*r]) ;		
            strcat((char*)szStmtBuffer, (char*)szAuxBuffer);
			if(nPrint) printf("\n> %s\n", szStmtBuffer) ;
			retcode = SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS) ;
			if(SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
			}else{
				p->nError = 1 ;
				printf("UPDATE in thread #%d failed\n", p->nThreadID) ;
				HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
			}
			}
        break ;


        /************************************** T_DELETE case **************************************/
        case T_DELETE:
            for(r = 0 ; r < nNoOfRows ; ++r){
                sprintf((char*)szStmtBuffer, "DELETE * FROM %s WHERE COL0 = %f", p->szTableName, pRef[nNoOfCol*r]) ;
                if(nPrint) printf("\n> %s\n", szStmtBuffer) ;
				retcode = SQLExecDirect(stHandles.hstmt, (SQLCHAR*)szStmtBuffer, SQL_NTS) ;
				if(SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
				}else if( 1 == p->nVerifyFlag && SQL_NO_DATA != retcode){
					p->nError = 1 ;
                    printf("\nVerification failed: still row exists\n") ;
				}else{
					p->nError = 1 ;
					printf("DELETE in thread #%d failed\n", p->nThreadID) ;
					HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
				}
			}
        break ;


        /************************************** default case **************************************/
        default:
            break ;
        }//switch
p->thread_status = S_IDLE ;
        } //for

free((void*)pBindBuffer) ;
GetHandles(&stHandles, FREE, 0) ;
p->thread_status = S_EXIT ;
return 0 ;	
    };



/*************************************************
Function: ThreadFnDouble - thread function
for double attributes
*************************************************/
/*
void* ThreadFnDouble(void* pparams){

    SQLRETURN retcode = SQL_ERROR ;
    SQLCHAR	szStmtBuffer[MAX_SQL_STMT] = { 0 } ;
    SQLCHAR szValueBuffer[MAX_VALUE_LEN] = { 0 } ;
    SQLCHAR szAuxBuffer[MAX_STR_LEN] = { 0 } ;
    SQLCHAR szColBuffer[MAX_COL_NAME] = { 0 } ;
    SQLINTEGER cbDouble = 0 ;
    ODBC_HANDLES stHandles ;
    memset(&stHandles, 0, sizeof(ODBC_HANDLES)) ;
    int r = 0, j = 0 ;

    //Get thread parameters 	
    PARAMS* p = (PARAMS*)pparams ;
    double* pRef = (double*)p->pThreadRef ;

    double* pBindBuffer = (double*)malloc(sizeof(double)*nNoOfCol) ;

    //printf("Thread #%d\n", p->nThreadID) ;

    retcode = GetHandles(&stHandles, GET, 0) ;
	
	if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode ) {
		p->report_status = S_STARTED ;
	}else{
		printf("Thread #%d failed to allocate handles, exiting now.\n", p->nThreadID) ;
		free((void*)pBindBuffer) ;
		p->report_status = S_EXIT ;
		return 0 ;
	}
    //p->report_status = S_STARTED ;

    //Main thread loop
    for(;;){

        while(S_IDLE == p->thread_status){
            NdbSleep_MilliSleep(1) ;
            }

    if(S_STOP == p->thread_status) {
        break ;
        }else{
            p->thread_status = S_BUSY ;
            }

    switch(p->op_type){


  /************************************** T_INSERT case **************************************/
  /*     case T_INSERT:

            for(r = 0 ; r < nNoOfRows ; ++r){	
                sprintf((char*)szStmtBuffer, "INSERT INTO %s VALUES(", p->szTableName) ; 
                for(j = 0 ;;){
                    sprintf((char*)szValueBuffer,"%.9f", pRef[nNoOfCol*r + j]) ;
                    strncat((char*)szStmtBuffer, (char*)szValueBuffer, strlen((const char*)szValueBuffer)) ;
                    ++j ;
                    if(nNoOfCol == j) break ;
                    strcat((char*)szStmtBuffer, ", ") ;
                    }
            strcat((char*)szStmtBuffer, ")") ;
            ODBC_FN(SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS), retcode) ;
                }

        break ;


  /************************************** T_READ case **************************************/
  /*      case T_READ:

            for(r = 0 ; r < nNoOfRows ; ++r){
                sprintf((char*)szStmtBuffer, "SELECT * FROM %s WHERE COL0 = %.9f", p->szTableName, pRef[nNoOfCol*r]) ;
                ODBC_FN(SQLExecDirect(stHandles.hstmt, (SQLCHAR*)szStmtBuffer, SQL_NTS), retcode) ;
                for(j = 0 ; j < nNoOfCol ; ++j){
                    ODBC_FN(SQLBindCol(stHandles.hstmt, (j+1), SQL_C_DOUBLE, (void*)&pBindBuffer[j], sizeof(SQLDOUBLE), &cbDouble), retcode) ;
                    }
            for (;;) {
                retcode = SQLFetch(stHandles.hstmt);

                if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
                    for(int k = 0 ; k < nNoOfCol ; ++k){
                        if(p->nVerifyFlag){
                            if(abs(pBindBuffer[k] - pRef[nNoOfCol*r + k]) > DBLDEV)
                                printf("Expected: %.9f Actual: %.9f\n", pBindBuffer[k], pRef[nNoOfCol*r + k]) ;
                            }
                        }
                    }else if(SQL_NO_DATA == retcode){
                        break ;
                        }else{
                            HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
                            }
                    //printf("\n") ;
                }
        SQLCloseCursor(stHandles.hstmt) ;
                }
        break ;


    /************************************** T_UPDATE case **************************************/
    /*    case T_UPDATE:
            for(r = 0 ; r < nNoOfRows ; ++r){

                sprintf((char*)szStmtBuffer, "UPDATE %s SET ", p->szTableName) ; 
                for(j = 1 ;;){
                    pRef[nNoOfCol*r + j] = pRef[nNoOfCol*r + j] + UPDATE_VALUE ;
                    sprintf((char*)szColBuffer,"COL%d = %.9f",  j, pRef[nNoOfCol*r + j]) ;
                    strncat((char*)szStmtBuffer, (char*)szColBuffer, strlen((char*)szColBuffer)) ;
                    ++j ;
                    if(nNoOfCol == j) break ;
                    strcat((char*)szStmtBuffer, ", ") ;
                    }
            sprintf((char*)szAuxBuffer, " WHERE COL0 = %.9f ;", pRef[nNoOfCol*r]) ;		
            strcat((char*)szStmtBuffer, (char*)szAuxBuffer);	
            ODBC_FN(SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS), retcode) ;
                }
        break ;


  /************************************** T_DELETE case **************************************/
  /*      case T_DELETE:
            for(r = 0 ; r < nNoOfRows ; ++r){
                sprintf((char*)szStmtBuffer, "DELETE FROM %s WHERE COL0 = %.9f", p->szTableName, pRef[nNoOfCol*r]) ;
                retcode = SQLExecDirect(stHandles.hstmt, (SQLCHAR*)szStmtBuffer, SQL_NTS) ;
                if( 1 == p->nVerifyFlag && SQL_NO_DATA != retcode ){
                    printf("\nVerification failed: still row exists\n") ;
                    }
                }
        break ;


    /************************************** default case **************************************/
    /*    default:
            break ;
        }//switch
p->thread_status = S_IDLE ;
        } //for

free((void*)pBindBuffer) ;
GetHandles(&stHandles, FREE, 0) ;
p->thread_status = S_EXIT ;
return 0 ;	
    };



/*************************************************
Function: ThreadFnChar - thread function
for character attributes
*************************************************/
void* ThreadFnChar(void* pparams){

    SQLRETURN retcode = SQL_ERROR ;
    SQLCHAR	szStmtBuffer[MAX_SQL_STMT] = { 0 } ;
    SQLCHAR szValueBuffer[MAX_VALUE_LEN] = { 0 } ;
    SQLCHAR szAuxBuffer[MAX_STR_LEN] = { 0 } ;
    SQLCHAR szColBuffer[MAX_COL_NAME] = { 0 } ;
    SQLINTEGER cbChar = 0 ;
    ODBC_HANDLES stHandles ;
    memset(&stHandles, 0, sizeof(ODBC_HANDLES)) ;
    int r = 0, j = 0 ;

    //Get thread parameters 	
    PARAMS* p = (PARAMS*)pparams ;
    char* pRef = (char*)p->pThreadRef ;
    char* pBindBuffer = (char*)malloc(sizeof(char)*nNoOfCol*MAX_CHAR_ATTR_LEN) ;

    //printf("Thread #%d\n", p->nThreadID) ;

    retcode = GetHandles(&stHandles, GET, 0) ;
	
	if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode ) {
		p->report_status = S_STARTED ;
	}else{
		printf("Thread #%d failed to allocate handles, retcode = %d, exiting now.\n", p->nThreadID, retcode) ;
		p->nError = 1 ;
		free((void*)pBindBuffer) ;
		p->report_status = S_EXIT ;
		return 0 ;
	}

    //Main thread loop
    for(;;){
		
		while(S_IDLE == p->thread_status){
            NdbSleep_MilliSleep(1) ;
		}

		if(S_STOP == p->thread_status) {
			break ;
        }else{
            p->thread_status = S_BUSY ;
		}

		switch(p->op_type){


        /************************************** T_INSERT case **************************************/
        case T_INSERT:

            for(r = 0 ; r < nNoOfRows ; ++r){
                memset(szStmtBuffer, 0, strlen(szStmtBuffer)) ;
				if(!nColList){
					sprintf((char*)szStmtBuffer, "INSERT INTO %s VALUES(", p->szTableName) ; 
				}else{
					sprintf((char*)szStmtBuffer, "INSERT INTO %s (%s) VALUES(", p->szTableName, szColNames) ;
				}

                for(j = 0 ;;){
                    sprintf((char*)szValueBuffer,"'%s'", (char*)(pRef + nNoOfCol*r*MAX_CHAR_ATTR_LEN*sizeof(char) + j*MAX_CHAR_ATTR_LEN*sizeof(char))) ;
                    strncat((char*)szStmtBuffer, (char*)szValueBuffer, strlen((const char*)szValueBuffer)) ;
                    ++j ;
                    if(nNoOfCol == j) break ;
                    strcat((char*)szStmtBuffer, ", ") ;
                    }
            strcat((char*)szStmtBuffer, ")") ;
			
			if(nPrint) printf("\n> %s\n", szStmtBuffer) ;
			retcode = SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS) ;
			if(SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
			}else{
				p->nError = 1 ;
				printf("INSERT in thread #%d failed\n", p->nThreadID) ;
				HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
			}
			}

        break ;


        /************************************** T_READ case **************************************/
        case T_READ:

            for(r = 0 ; r < nNoOfRows ; ++r){
                sprintf((char*)szStmtBuffer, "SELECT * FROM %s WHERE COL0 = '%s'", p->szTableName, (char*)(pRef + nNoOfCol*r*MAX_CHAR_ATTR_LEN*sizeof(char))) ;
       			if(nPrint) printf("\n> %s\n", szStmtBuffer) ;
				ODBC_FN(SQLExecDirect(stHandles.hstmt, (SQLCHAR*)szStmtBuffer, SQL_NTS), retcode) ;
                for(j = 0 ; j < nNoOfCol ; ++j){
                    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) ;
                    }
            for (;;) {
				retcode = SQLFetch(stHandles.hstmt);

                if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
					for(int k = 0 ; k < nNoOfCol ; ++k){
						if(p->nVerifyFlag){
                            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))))
                                printf("Expected: %s Actual: %s\n", (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))) ;
                            }
					}
				}else if(SQL_NO_DATA == retcode){
					break ;
				}else{
					p->nError = 1 ;
					printf("READ in thread #%d failed\n", p->nThreadID) ;
					HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
				}
                    //printf("\n") ;
			}
			SQLCloseCursor(stHandles.hstmt) ;
			}
        break ;


        /************************************** T_UPDATE case **************************************/
        case T_UPDATE:
            for(r = 0 ; r < nNoOfRows ; ++r){
                sprintf((char*)szStmtBuffer, "UPDATE %s SET ", p->szTableName) ; 
                for(j = 1 ;;){
                    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)) ;
                    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)) ;					
                    sprintf((char*)szColBuffer,"COL%d = '%s'",  j, (char*)(pRef + nNoOfCol*r*MAX_CHAR_ATTR_LEN*sizeof(char) + j*MAX_CHAR_ATTR_LEN*sizeof(char))) ;
                    strncat((char*)szStmtBuffer, (char*)szColBuffer, strlen((char*)szColBuffer)) ;
                    ++j ;
                    if(nNoOfCol == j) break ;
                    strcat((char*)szStmtBuffer, ", ") ;
                    }
            sprintf( (char*)szAuxBuffer, " WHERE COL0 = '%s';", (char*)(pRef + nNoOfCol*r*MAX_CHAR_ATTR_LEN*sizeof(char)) ) ;		
            strcat((char*)szStmtBuffer, (char*)szAuxBuffer) ;
			if(nPrint) printf("\n> %s\n", szStmtBuffer) ;
            retcode = SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS) ;
			if(SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
			}else{
				p->nError = 1 ;
				printf("UPDATE in thread #%d failed\n", p->nThreadID) ;
				HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
			}
			}
        break ;


        /************************************** T_DELETE case **************************************/
        case T_DELETE:
            for(r = 0 ; r < nNoOfRows ; ++r){
                sprintf((char*)szStmtBuffer, "DELETE FROM %s WHERE COL0 = '%s\'", p->szTableName, (char*)(pRef + nNoOfCol*r*MAX_CHAR_ATTR_LEN*sizeof(char))) ;
            	if(nPrint) printf("\n> %s\n", szStmtBuffer) ;
				retcode = SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS) ;
				if(SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
				}else if(1 == p->nVerifyFlag && SQL_NO_DATA != retcode){
                    p->nError = 1 ;
					printf("\nVerification failed: still row exists\n") ;
				}else{
					p->nError = 1 ;
					printf("INSERT in thread #%d failed\n", p->nThreadID) ;
					HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
                }
			}
        break ;


        /************************************** default case **************************************/
        default:
            break ;
		}//switch
	p->thread_status = S_IDLE ;
	} //for

	free((void*)pBindBuffer) ;
	GetHandles(&stHandles, FREE, 0) ;
	p->thread_status = S_EXIT ;
	return 0 ;	
};



/*************************************************
Function: CreateDemoTable
*************************************************/
SQLRETURN CreateDemoTables(char* szTableName, int nTables, table_opt op){

    SQLRETURN retcode = SQL_ERROR ;
    SQLCHAR	szStmtBuffer[MAX_SQL_STMT] = { 0 } ;
    SQLCHAR szColBuffer[MAX_COL_NAME] = { 0 } ;
	SQLCHAR szAuxBuffer[32] = { 0 } ;
    ODBC_HANDLES stHandles ;
    memset(&stHandles, 0, sizeof(ODBC_HANDLES)) ;
    int c = 0  ;
	
	GetHandles(&stHandles, GET, 0) ;

    if(CREATE == op){
		
        for(c = 0; c < nTables ; ++c){
			sprintf((char*)szStmtBuffer, "CREATE TABLE %s (", (char*)(szTableName+MAX_TABLE_NAME*c)) ;
            int j = 0 ;
			for(;;){
				sprintf((char*)szColBuffer, "COL%d ", j) ;
                strcat((char*)szStmtBuffer, (char*)szColBuffer) ;
                ++j ;

                switch(AttributeType){
                    case T_INT:
                        strcat((char*)szStmtBuffer, "INTEGER") ;
                        break ;
                    case T_FLOAT:
                        strcat((char*)szStmtBuffer, "FLOAT") ;
                        break ;

/*                    case T_DOUBLE:
                        strcat((char*)szStmtBuffer, "DOUBLE") ;
                        break ;
*/
                    case T_CHAR:
						sprintf((char*)szAuxBuffer, "CHAR(%d)", MAX_CHAR_ATTR_LEN) ;
						strcat((char*)szStmtBuffer,  (char*)szAuxBuffer) ;
                        break ;
                    default:
                        break ;
				}

				if(nNoOfCol <= j){	
					strcat((char*)szStmtBuffer, ")") ;
					break ;
				}	
				strcat((char*)szStmtBuffer, ", ") ;				
            } //for(;;)
			
			
			if(nPrint) printf("\n> %s\n", szStmtBuffer) ;
			ODBC_FN(SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS), retcode) ;
			if(SQL_SUCCESS != retcode) HandleError(stHandles.hstmt , SQL_HANDLE_STMT) ;

			
		}// for()

	}else{
		
		for(c = 0 ; c < nTables ; ++c){
			sprintf((char*)szStmtBuffer, "DROP TABLE %s ", (char*)(szTableName + MAX_TABLE_NAME*c)) ;
			//ODBC_FN(SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS), retcode) ;
			if(nPrint) printf("\n> %s\n", szStmtBuffer) ;
			retcode = SQLExecDirect(stHandles.hstmt, szStmtBuffer, SQL_NTS) ;
		}

	}

    GetHandles(&stHandles, FREE, 0) ;

    return retcode ;
}



/*************************************************
Function: AssignTableNames()
*************************************************/
inline void AssignTableNames(char* szBuffer, int nTables){
    for(int c = 0 ; c < nTables ; ++c){
        sprintf((char*)(szBuffer + MAX_TABLE_NAME*sizeof(char)*c), "TAB%d", c) ;
        }
return ;
    }




/*************************************************
Function: StartThreads()
*************************************************/

inline void StartThreads(PARAMS* p, void* pRef, int nTables, char* szTables, attr_type attrType, UintPtr* pHandles) {

    int* pInt = NULL ;
    float* pFloat = NULL ;
    double* pDouble = NULL ;
    char* pChar = NULL ;
	UintPtr pTmpThread = NULL ;

    bool bFlap = 1 ;
    for(int f = 0 ; f < nNoOfThreads ; ++f){
        p[f].nThreadID = f ;
        p[f].nError = 0 ;
        p[f].thread_status = S_IDLE ;
        p[f].op_type = T_WAIT ;
        if(bFlap){
			strncpy((char*)p[f].szTableName, (char*)szTables, MAX_TABLE_NAME) ;
		}else{
            strncpy((char*)p[f].szTableName, (char*)(szTables + MAX_TABLE_NAME*sizeof(char)), MAX_TABLE_NAME) ;
		}
        bFlap = !bFlap ;
		//pTmpThread = pHandles[ ;

        switch(attrType){
            case T_INT:
                pInt = (int*)pRef ;
                p[f].pThreadRef = (void*)&pInt[nNoOfRows*nNoOfCol*f] ;
                pHandles[f] = (UintPtr)NdbThread_Create(ThreadFnInt, (void**)&p[f], 32768, "SQL99_test", NDB_THREAD_PRIO_MEAN) ;
                break ;
            case T_FLOAT:
                pFloat = (float*)pRef ;
                p[f].pThreadRef = (void*)&pFloat[nNoOfRows*nNoOfCol*f] ;
                pHandles[f] = (UintPtr)NdbThread_Create(ThreadFnFloat, (void**)&p[f], 32768, "SQL99_test", NDB_THREAD_PRIO_MEAN) ;
                break ;
            /*
			case T_DOUBLE:
                pDouble = (double*)pRef ;
                p[f].pThreadRef = (void*)&pDouble[nNoOfRows*nNoOfCol*f] ;
                pHandles[f] = (UintPtr)NdbThread_Create(ThreadFnDouble, (void**)&p[f], 32768, "SQL99_test", NDB_THREAD_PRIO_MEAN) ;
                break ;
			*/
            case T_CHAR:
                pChar = (char*)pRef ;
                p[f].pThreadRef = (void*)&pChar[nNoOfRows*nNoOfCol*f*MAX_CHAR_ATTR_LEN] ;
                pHandles[f] = (UintPtr)NdbThread_Create(ThreadFnChar,  (void**)&p[f], 32768, "SQL99_test", NDB_THREAD_PRIO_MEAN) ;
            default:
                break ;
            }
    while(!(S_STARTED != p[f].report_status || S_EXIT != p[f].report_status)){
        NdbSleep_MilliSleep(1) ;
	}
        }
	return ;
}



/*************************************************
Function: SetThreadOperationType()
*************************************************/
inline void SetThreadOperationType(PARAMS* p, type op){

    for(int e = 0 ; e < nNoOfThreads ; ++e){	
        p[e].nVerifyFlag = 0 ;
        if(T_READ_VERIFY == op){
            p[e].nVerifyFlag = 1 ;
            p[e].op_type = T_READ ;
            }else if(T_DELETE_VERIFY == op){
                p[e].nVerifyFlag = 1 ;
                p[e].op_type = T_DELETE ;
                }else{
                    p[e].op_type = op ;
                    }
            p[e].thread_status = S_GET_BUSY ;
        }
return ;
    }



/*************************************************
Function: WaitForThreads()
*************************************************/
inline int WaitForThreads(PARAMS* p) {
	
	int ret_value = 0 ;
    for(int w = 0 ; w < nNoOfThreads ; ++w){
        while(!(S_IDLE != p[w].thread_status || S_EXIT != p[w].report_status)) {
            NdbSleep_MilliSleep(1) ;
		}
		ret_value += p[w].nError ;
	}
	return ret_value ;
}



/*************************************************
Function: StopThreads()
*************************************************/
inline void StopThreads(PARAMS* p, UintPtr* pHandles) {

    for(int k = 0 ; k < nNoOfThreads ; ++k){
		while(!(S_IDLE != p[k].thread_status || S_EXIT != p[k].report_status)){
			NdbSleep_MilliSleep(1) ;
		}
		p[k].thread_status = S_STOP ;
		while(!(S_EXIT != p[k].thread_status || S_EXIT != p[k].report_status)){
			NdbSleep_MilliSleep(1) ;
		}
		NdbThread_Destroy((NdbThread**)&pHandles[k]) ;
	}

	return ;
}



/*************************************************
Function: PrintAll()
*************************************************/
inline void PrintAll(char* szTableName, int nTables, attr_type attrType){

    SQLRETURN retcode = SQL_ERROR ;
    SQLCHAR* szStmt[MAX_SQL_STMT] = { 0 } ;
    ODBC_HANDLES stHandles ;
    memset(&stHandles, 0, sizeof(ODBC_HANDLES)) ;
    double* pDoubleBuffer = NULL ;
    char* pCharBuffer = NULL ;

    if(T_CHAR != attrType){
        pDoubleBuffer = (double*)malloc(sizeof(double)*nNoOfCol) ;
	}else{
         pCharBuffer = (char*)malloc(sizeof(char)*nNoOfCol*MAX_CHAR_ATTR_LEN) ;
	}

    SQLINTEGER   cbLen = 0 ;

    GetHandles(&stHandles, GET, 0) ;

    for(int c = 0 ; c < nTables ; ++c){

        int nCol = 0, nRows = 0 ;

        printf("Table: \"%s\":\n------------------\n", (char*)(szTableName + MAX_TABLE_NAME*c*sizeof(char))) ;

        sprintf((char*)szStmt, "SELECT * FROM %s", (char*)(szTableName + MAX_TABLE_NAME*c*sizeof(char))) ;
		if(nPrint) printf("\n> %s\n", szStmt) ;
        ODBC_FN(SQLExecDirect(stHandles.hstmt, (SQLCHAR*)szStmt, SQL_NTS), retcode) ;

        for(int i = 0 ; i < nNoOfCol ; ++i){

            if(T_CHAR != attrType){
                ODBC_FN(SQLBindCol(stHandles.hstmt, (i+1), SQL_C_DOUBLE, (void*)&pDoubleBuffer[i], sizeof(SQLDOUBLE), &cbLen), retcode) ;
			}else{
                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) ;
			}
            nCol++ ;

		}

    int k = 0 ;	//out of the <for> loop
    for (;;) {

        retcode = SQLFetch(stHandles.hstmt);			
        if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode ){
            for(k = 0 ; k < nNoOfCol ; ++k){
                if(T_CHAR != attrType){
                    ATTR_TYPE_SWITCH_T(pDoubleBuffer[k], AttributeType) ;
                    }else{
                        printf("%s\t", (char*)(pCharBuffer + k*MAX_CHAR_ATTR_LEN)) ;
					}
                }
            }else if(SQL_NO_DATA == retcode){
                if(0 == k){
                    printf("<empty>\n") ;
                    break ;
                    }else{
                        break ;
					}
                }else{
                    HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
				}

            ++nRows ;
            printf("\n") ;
        }

	SQLCloseCursor(stHandles.hstmt) ;

	printf("------------------\n") ;
	printf("Rows: %d Columns: %d\n\n", nRows, nCol) ;

			}

	free((void*)pDoubleBuffer) ;
	free((void*)pCharBuffer) ;
	GetHandles(&stHandles, FREE, 0) ;

	return ;
}



/*************************************************
Function: AssignRefCharValues()
*************************************************/
void AssignRefCharValues(char* pRef, bool bVerbose) {

    int count = 0, rows = 0, nThreadOffset = 0, nRowOffset = 0 ;
    char szStrBuffer[MAX_CHAR_ATTR_LEN] = { 0 } ;
    int char_count = sizeof(szANSI)/sizeof(char) ;

    for(int c = 0 ; c < nNoOfThreads ; ++c){
        nThreadOffset = nNoOfRows*nNoOfCol*c*MAX_CHAR_ATTR_LEN*sizeof(char) ;
        for(int d = 0 ; d < nNoOfRows ; ++d){
            nRowOffset = nNoOfCol*d*MAX_CHAR_ATTR_LEN*sizeof(char) ; ++rows ;
            for(int i = 0 ; i < nNoOfCol ; ++i){
                for(int j = 0 ; j < (MAX_CHAR_ATTR_LEN - 2) ; ++j){
                    int h = (char)(rand() % (char_count-1)) ;
                    szStrBuffer[j] = szANSI[h] ;
                    }
            szStrBuffer[MAX_CHAR_ATTR_LEN - 1] = '\0' ;

            strcpy((char*)(pRef + nThreadOffset + nRowOffset + i*MAX_CHAR_ATTR_LEN*sizeof(char)), (char*)szStrBuffer) ;
            count++ ;
            if(bVerbose){
                printf(" %s ", (char*)(pRef + nThreadOffset + nRowOffset + i*MAX_CHAR_ATTR_LEN*sizeof(char))) ;
                }
                }
        if(bVerbose) { 
            printf("\n") ;
            NdbSleep_MilliSleep(10) ;
            }
            }
        }

if(bVerbose){
    printf("_____________________") ;
    printf("\nRows: %d Values: %d\n\n", rows, count) ;
    }

return ;
    }


/*


sprintf((char*)szStmtBuffer, "INSERT INTO %s VALUES(", p->szTableName) ; 				
for(j = 0 ;;){
strcat((char*)szStmtBuffer, "?") ;
++j ;
if(nNoOfCol == j) break ;
strcat((char*)szStmtBuffer, ", ") ;
}
strcat((char*)szStmtBuffer, ")") ;

ODBC_FN(SQLPrepare(stHandles.hstmt, szStmtBuffer, SQL_NTS), retcode) ;

for(j = 0 ; j < nNoOfCol ; ++j){
ODBC_FN(SQLBindParameter(stHandles.hstmt, (j+1), SQL_PARAM_INPUT, SQL_C_FLOAT, SQL_FLOAT, 0, 0, (void*)&pBindBuffer[j], 0, &cbFloat), retcode) ;
HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
}

for(r = 0 ; r < nNoOfRows ; ++r){
for(j = 0 ; j < nNoOfCol ; ++j){
pBindBuffer[j] = pRef[nNoOfCol*r + j] ;
}
ODBC_FN(SQLExecute(stHandles.hstmt), retcode) ;
HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
}

*/




/*************************************************
Function: HandleError
*************************************************/

void HandleError(void* handle, SQLSMALLINT HandleType){

    SQLCHAR szError[MAX_STR_LEN], szSqlState[32] ;
    SQLINTEGER nError = 0 ;
    SQLSMALLINT nHandleType = HandleType ;
    SQLSMALLINT nLength = 0 ;
    SQLHANDLE SQLHandle = handle ;
    SQLGetDiagRec(nHandleType, SQLHandle, 1, szSqlState, &nError, szError, 128, &nLength) ;
    printf("Error: %s\nSqlState: %s\n", szError, szSqlState) ;

    return ;
    }



/*************************************************
Function: ReportError
*************************************************/

void ReportError(char* szFn, char* szBuffer, char* szFile, int iLine){

    printf("%s %s\nFile: %s\nLine: %d\n", szFn, szBuffer, szFile, iLine) ;

    return ;
}



/*************************************************
Function: GetHandles()
*************************************************/

SQLRETURN GetHandles(ODBC_HANDLES* pHandles, handle_op op, bool bDriverInfo){

    SQLRETURN   retcode = SQL_ERROR ;

    if(GET == op){
		
		retcode = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &pHandles->henv);

        if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode ) {
			retcode = SQLSetEnvAttr(pHandles->henv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC2, 0);

            if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode) {
				retcode = SQLAllocHandle(SQL_HANDLE_DBC, pHandles->henv, &pHandles->hdbc);

                if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode) {
                    
					//SQLSetConnectAttr(pHandles->hdbc, SQL_LOGIN_TIMEOUT, (void*)5, 0);
					
					retcode = SQLConnect(pHandles->hdbc, (SQLCHAR*)"", SQL_NTS, (SQLCHAR*)"", SQL_NTS, (SQLCHAR*)"", SQL_NTS ) ;
					
					SQL_SUCCESS == SQLSetConnectAttr(pHandles->hdbc, SQL_ATTR_AUTOCOMMIT, (void*)SQL_AUTOCOMMIT_ON, 0) ;
						//printf("AUTOCOMMIT is on\n") ; 
					
					if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode)	{
						// retcode still holds the value returned by SQLConnect
					    retcode = SQLAllocHandle(SQL_HANDLE_STMT, pHandles->hdbc, &pHandles->hstmt) ;
						if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode) {
							if(bDriverInfo) GetDriverAndSourceInfo(pHandles->hdbc) ;
							// printf("All handles allocated OK\n", retcode);
						}else{ // SQLAllocHandle()
							REPORTERROR((char*)"SQLAllocHandle()", (char*)"failed") ;
							HandleError(pHandles->hdbc, SQL_HANDLE_DBC) ;
							ODBC_FN(SQLDisconnect(pHandles->hdbc), retcode) ;
							ODBC_FN(SQLFreeHandle(SQL_HANDLE_DBC, pHandles->hdbc), retcode) ;
							ODBC_FN(SQLFreeHandle(SQL_HANDLE_ENV, pHandles->henv), retcode) ;
							retcode = SQL_ERROR ;
						}
					}else{ // SQLConnect()
						REPORTERROR((char*)"SQLConnect()", (char*)"failed" ) ;
						HandleError(pHandles->hdbc, SQL_HANDLE_DBC) ;
						ODBC_FN(SQLFreeHandle(SQL_HANDLE_DBC, pHandles->hdbc), retcode) ;
						ODBC_FN(SQLFreeHandle(SQL_HANDLE_ENV, pHandles->henv), retcode) ;
						retcode = SQL_ERROR ;
					}
				}else{ // SQLAllocHandle()
					REPORTERROR((char*)"SQLAllocHandle()", "failed" ) ;
					HandleError(pHandles->hdbc, SQL_HANDLE_DBC) ;
					ODBC_FN(SQLFreeHandle(SQL_HANDLE_ENV, pHandles->henv), retcode) ;
					retcode = SQL_ERROR ;
				}
			}else{ // SQLSetEnvAttr()
				REPORTERROR((char*)"SQLSetEnvAttr()", "failed" ) ;
				HandleError(pHandles->henv, SQL_HANDLE_ENV) ;
				ODBC_FN(SQLFreeHandle(SQL_HANDLE_ENV, pHandles->henv), retcode) ;
				retcode = SQL_ERROR ;
			}
		}else{ // SQLAllocHandle()
			REPORTERROR((char*)"SQLAllocHandle()", "failed" ) ;
			HandleError(pHandles->henv, SQL_HANDLE_ENV) ;
			retcode = SQL_ERROR ;
		}
	}else{
			ODBC_FN(SQLFreeHandle(SQL_HANDLE_STMT, pHandles->hstmt), retcode) ;
			ODBC_FN(SQLDisconnect(pHandles->hdbc), retcode) ;
			ODBC_FN(SQLFreeHandle(SQL_HANDLE_DBC, pHandles->hdbc), retcode) ;
			ODBC_FN(SQLFreeHandle(SQL_HANDLE_ENV, pHandles->henv), retcode) ;
	}

    return retcode ;
}



/*************************************************
Function: AggretateFn():
<aggr_fn fn> - name of the aggregate function to use
<char* szTableName> - name of the table
<int nCol> - number of the column
<double* pdIn> - pointer to double containing the value to be used in a call to COUNT; used only by this function
<double* pdOut> - pointer to double that will recieve the result
<attr_type attrType> - type of the attribute
*************************************************/
SQLRETURN AggregateFn(aggr_fn fn, char* szTableName, int nCol, double* pdIn, double* pdOut, attr_type attrType){

    SQLRETURN retcode = SQL_ERROR ;
    SQLCHAR* szStmt[MAX_SQL_STMT] = { 0 } ;
    SQLCHAR szValueBuffer[MAX_VALUE_LEN] = { 0 } ;
    SQLCHAR szAuxBuffer[MAX_STR_LEN] = { 0 } ;
    SQLCHAR szColBuffer[MAX_COL_NAME] = { 0 } ;
    ODBC_HANDLES stHandles ;
    memset(&stHandles, 0, sizeof(ODBC_HANDLES)) ;
    SQLINTEGER  cbDouble = 0 ;

    GetHandles(&stHandles, GET, 0) ;

    switch(fn){
    case FN_COUNT:
        switch(attrType){
    case T_INT:
        sprintf((char*)szStmt, "SELECT COUNT(*) FROM %s WHERE COL%d > %d", szTableName, nCol, (int)*pdIn) ;
        break ;
    case T_FLOAT:
        sprintf((char*)szStmt, "SELECT COUNT(*) FROM %s WHERE COL%d > %f", szTableName, nCol, (float)*pdIn) ;
        break ;
/*    case T_DOUBLE:
        sprintf((char*)szStmt, "SELECT COUNT(*) FROM %s WHERE COL%d > %.15f", szTableName, nCol, *pdIn) ;
        break ;
*/
    default:
        break ;
            }
    break ;
    case FN_SUM:
        sprintf((char*)szStmt, "SELECT SUM(COL%d) FROM %s", nCol, szTableName) ;
        break ;
    case FN_AVG:
        sprintf((char*)szStmt, "SELECT AVG(COL%d) FROM %s", nCol, szTableName) ;
        break ;
    case FN_MAX:
        sprintf((char*)szStmt, "SELECT MAX(COL%d) FROM %s", nCol, szTableName) ;
        break ;
    case FN_MIN:
        sprintf((char*)szStmt, "SELECT MIN(COL%d) FROM %s", nCol, szTableName) ;
        break ;
    case FN_VARIANCE: // not implemented
        //sprintf((char*)szStmt, "SELECT VARIANCE(COL%d) FROM %s;", nCol, szTableName) ;
        break ;
    case FN_STDDEV: // not implemented
        //sprintf((char*)szStmt, "SELECT STDDEV(COL%d) FROM %s;", nCol, szTableName) ;
        break ;
    default:
        break ;
        }
//printf("%s\n", szStmt) ; 

retcode = SQLExecDirect(stHandles.hstmt, (SQLCHAR*)szStmt, SQL_NTS) ;
if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode ){
    retcode = SQLBindCol(stHandles.hstmt, 1, SQL_C_DOUBLE, (void*)pdOut, sizeof(SQLDOUBLE), &cbDouble) ;
    if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode ){
        retcode = SQLFetch(stHandles.hstmt) ;
        }
    }

if(SQL_SUCCESS != retcode && SQL_SUCCESS_WITH_INFO != retcode){
    HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
    }

SQLCloseCursor(stHandles.hstmt) ;

GetHandles(&stHandles, FREE, 0) ;

return retcode ;

    };



/*************************************************
Function: GetDriverAndSourceInfo()
*************************************************/
SQLRETURN GetDriverAndSourceInfo(SQLHDBC hdbc){

    SQLRETURN retcode = SQL_ERROR ;

    SQLCHAR			buffer[255] ;
    SQLUSMALLINT	snValue = 0 ;
    SQLSMALLINT		outlen =  0 ;

    printf( "-------------------------------------------\n" ) ;

    retcode = SQLGetInfo( hdbc, SQL_DATA_SOURCE_NAME, buffer, 255, &outlen ) ;

    printf( "Connected to Server: %s\n", buffer ) ;

    retcode = SQLGetInfo( hdbc, SQL_DATABASE_NAME, buffer, 255, &outlen ) ;
    printf( "      Database name: %s\n", buffer ) ;

    retcode = SQLGetInfo( hdbc, SQL_SERVER_NAME, buffer, 255, &outlen ) ;
    printf( "      Instance name: %s\n", buffer ) ;

    retcode = SQLGetInfo( hdbc, SQL_DBMS_NAME, buffer, 255, &outlen ) ;
    printf( "          DBMS name: %s\n", buffer ) ;

    retcode = SQLGetInfo( hdbc, SQL_DBMS_VER, buffer, 255, &outlen ) ;
    printf( "       DBMS version: %s\n", buffer ) ;

    retcode = SQLGetInfo( hdbc, SQL_ODBC_VER, buffer, 255, &outlen ) ;
    printf( "       ODBC version: %s\n", buffer ) ;

    retcode = SQLGetInfo( hdbc, SQL_DRIVER_NAME, buffer, 255, &outlen ) ;
    printf( "        Driver name: %s\n", buffer ) ;

    retcode = SQLGetInfo( hdbc, SQL_DRIVER_VER, buffer, 255, &outlen ) ;
    printf( "     Driver version: %s\n", buffer ) ;

    retcode = SQLGetInfo( hdbc, SQL_MAX_DRIVER_CONNECTIONS, &snValue, sizeof(SQLSMALLINT), &outlen ) ;
    printf( "    Max connections: %d\n", snValue ) ;

    retcode = SQLGetInfo( hdbc, SQL_CURSOR_COMMIT_BEHAVIOR, &snValue, sizeof(SQLSMALLINT), &outlen ) ;
    printf( "Autocommit behavior:") ;

    switch(snValue){
    case SQL_CB_DELETE:
        printf(" SQL_CB_DELETE\n") ;
        break ;
    case SQL_CB_CLOSE:
        printf(" SQL_CB_CLOSE\n") ;
        break ;
    case SQL_CB_PRESERVE:
        printf(" SQL_CB_PRESERVE\n") ;
        break ;
    default:
        printf(" undefined\n") ;
        break ;
        }

	printf( "-------------------------------------------\n" ) ;

	return retcode ;

}



/*************************************************
Function: ArithOp()
*************************************************/

int ArithOp(char* szTable, int nTotalCols, float* pValue, attr_type attrType, arth_op op){
	
    SQLRETURN retcode = SQL_ERROR ;
	int nVerRet = -1 ;
    SQLCHAR szStmt[MAX_SQL_STMT] = { 0 } ;
    SQLCHAR szEndBuffer[MAX_STR_LEN] = { 0 } ;
    SQLCHAR szColBuffer[MAX_COL_NAME] = { 0 } ;
    SQLCHAR szAuxBuffer[MAX_STR_LEN] = { 0 } ;
    ODBC_HANDLES stHandles ;
    memset(&stHandles, 0, sizeof(ODBC_HANDLES)) ;

    void* pBuffer = NULL ;
    SQLINTEGER BindInt = 0, IntResult = 0, RefIntResult = 0 ;
    SQLFLOAT BindFloat = 0, FloatResult = 0, RefFloatResult = 0 ;
    SQLDOUBLE BindDouble = 0, DoubleResult = 0, RefDoubleResult = 0 ;
    SQLINTEGER cbSize = 0 ;
    SQLINTEGER  cbLen = 0 ;
    SQLSMALLINT cbTarget = 0 ;

    GetHandles(&stHandles, GET, 0) ;

    for(int c = 0 ; c < nTotalCols ; ++c){

		sprintf((char*)szStmt, "SELECT COL%d, (COL%d", c, c) ;
        switch(op){
        case MINUS:
            strcat((char*)szStmt, " - ") ;
            break ;
        case PLUS:
            strcat((char*)szStmt, " + ") ;
            break ;
        case MULTI:
            strcat((char*)szStmt, " * ") ;
            break ;
        case DIVIDE:
            strcat((char*)szStmt, " / ") ;
            break ;
        case MODULO:
            //strcat((char*)szStmt, " % ") ; Not implemented
            GetHandles(&stHandles, FREE, 0) ;
            return -1 ; //Close handles and return
            break ;
        default:
            break ;
		}

		sprintf((char*)(szAuxBuffer),"%.9f) ", *((float*)(pValue))) ;
		strcat((char*)szStmt, (char*)szAuxBuffer) ;
		sprintf((char*)szEndBuffer, "FROM %s", szTable) ;
		strcat((char*)szStmt, (char*)szEndBuffer) ;

		ODBC_FN(SQLExecDirect(stHandles.hstmt, (SQLCHAR*)szStmt, SQL_NTS), retcode) ;
		if(retcode == SQL_ERROR){
			HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ; 
			printf("\n%s\n", szStmt) ;
		}

		SQLSMALLINT cbNameLen = 0, cbSqlType = 0, cbNullable = 0, cbColScale = 0  ;
		SQLINTEGER cbColSize = 0 ;
		SQLDescribeCol(stHandles.hstmt, 2, szColBuffer, MAX_COL_NAME-1, &cbNameLen, &cbSqlType, (unsigned long*)&cbColSize, &cbColScale, &cbNullable) ;

		switch(cbSqlType){
			case SQL_NUMERIC:
				pBuffer = &IntResult ;
				cbSize = sizeof(SQLINTEGER) ;
				cbTarget = SQL_C_ULONG ;
			case SQL_INTEGER:
				pBuffer = &IntResult ;
				cbSize = sizeof(SQLINTEGER) ;
				cbTarget = SQL_C_LONG ;
				break ;
			case SQL_FLOAT:
				pBuffer = &FloatResult ; 
				cbSize = sizeof(SQLFLOAT) ;
				cbTarget = SQL_C_FLOAT ;
				break ;
			case SQL_DOUBLE:
				pBuffer = &DoubleResult ;
				cbSize = sizeof(SQLDOUBLE) ;
				cbTarget = SQL_C_DOUBLE ;
				break ;
			default:
				printf("\nUndefined result type: %d\n", cbSqlType) ;
				break ;
		}

		switch(attrType){
			case T_INT:
				ODBC_FN(SQLBindCol(stHandles.hstmt, 1, SQL_C_SLONG, (void*)&BindInt, sizeof(SQLINTEGER), &cbLen), retcode) ;
				break ;
			case T_FLOAT:
				ODBC_FN(SQLBindCol(stHandles.hstmt, 1, SQL_C_FLOAT, (void*)&BindFloat, sizeof(SQLFLOAT), &cbLen), retcode) ;
				break ;
	/*        case T_DOUBLE:
				ODBC_FN(SQLBindCol(stHandles.hstmt, 1, SQL_C_DOUBLE, (void*)&BindDouble, sizeof(SQLDOUBLE), &cbLen), retcode) ;
				break ;
	*/
			default:
				break ;
		}

		ODBC_FN(SQLBindCol(stHandles.hstmt, 2, cbTarget, pBuffer, cbSize, &cbLen), retcode) ;

		retcode = SQLFetch(stHandles.hstmt) ;

		if (SQL_SUCCESS == retcode || SQL_SUCCESS_WITH_INFO == retcode){
			switch(attrType){
				case T_INT:
					switch(cbSqlType){
						case SQL_INTEGER:
							nVerRet = VerifyArthOp((int*)&BindInt, pValue, (int*)pBuffer, op) ;
							break ;
						case SQL_FLOAT:
							nVerRet = VerifyArthOp((int*)&BindInt, pValue, (float*)pBuffer, op) ;
							break ;
						case SQL_DOUBLE:
							nVerRet = VerifyArthOp((int*)&BindInt, pValue, (double*)pBuffer, op) ;
							break ;
						case SQL_NUMERIC:
							nVerRet = VerifyArthOp((int*)&BindInt, pValue, (int*)pBuffer, op) ;
							break ;
						default:
							break ;
					}
					break ;

				case T_FLOAT:
					switch(cbSqlType){
						case SQL_INTEGER:
							nVerRet = VerifyArthOp((float*)&BindFloat, pValue, (int*)pBuffer, op) ;
							break ;
						case SQL_FLOAT:
							nVerRet = VerifyArthOp((float*)&BindFloat, pValue, (float*)pBuffer, op) ;
							break ;
						case SQL_DOUBLE:
							nVerRet = VerifyArthOp((float*)&BindFloat, pValue, (double*)pBuffer, op) ;
							break ;
						default:
							break ;
					}
					break ;
	/*                case T_DOUBLE:
						switch(cbSqlType){
					case SQL_INTEGER:
						nVerRet = VerifyArthOp((double*)&BindDouble, pValue, (int*)pBuffer, op) ;
						break ;
					case SQL_FLOAT:
						nVerRet = VerifyArthOp((double*)&BindDouble, pValue, (float*)pBuffer, op) ;
						break ;
					case SQL_DOUBLE:
						nVerRet = VerifyArthOp((double*)&BindDouble, pValue, (double*)pBuffer, op) ;
						break ;
					default:
						break ;
							}
					break ;
	*/
				default:
					break ;
			}
			if(-1 == nVerRet){
				printf("\nVerification failed.\n") ;
				return nVerRet ;
			}else if(SQL_NO_DATA == retcode){
				break ;
			}
		}else{

			HandleError(stHandles.hstmt, SQL_HANDLE_STMT) ;
		}

		SQLCloseCursor(stHandles.hstmt) ;
		}
		
		GetHandles(&stHandles, FREE, 0) ;
		
		return nVerRet ;
}




/*************************************************
Function: Join()
*************************************************/
SQLRETURN Join(char* szTable, int nTables, int nCol, join_type joinType){

    SQLRETURN retcode = SQL_ERROR ;
    SQLCHAR szStmt[MAX_SQL_STMT] = { 0 } ;
    SQLCHAR szEndBuffer[MAX_STR_LEN] = { 0 } ;
    SQLCHAR szColBuffer[MAX_COL_NAME] = { 0 } ;
    SQLCHAR szAuxBuffer[MAX_STR_LEN] = { 0 } ;

    ODBC_HANDLES stHandles ;
    memset(&stHandles, 0, sizeof(ODBC_HANDLES)) ;

    int c = 0, t = 0 ;

    GetHandles(&stHandles, GET, 0) ;

    for(c = 0 ; c < nCol ; ++c) {

        switch(joinType){
        case ITSELF:
            sprintf((char*)szStmt, "SELECT * FROM %s, %s", (char*)szTable, (char*)szTable) ;
            break ;
        case EQUI:
            break ;
        case NON_EQUI:
            break ;
        case INNER:
            break ;
        case OUTTER:
            break ;
        default:
            break ;
            }
        }

GetHandles(&stHandles, FREE, 0) ;

return retcode ;

}



SQLRETURN GetResults(SQLHSTMT){

    SQLRETURN retcode = SQL_ERROR ;

    return retcode ;
}

/*

int createTables(char* szTableName, int nTables){
  
	for (int i = 0; i < nNoOfCol; i++){
		snprintf(attrName[i], MAXSTRLEN, "COL%d", i) ;
	}

	for (int i = 0; i < nTables; i++){
		snprintf(tableName[i], MAXSTRLEN, "TAB%d", i) ;
	}
  
	for(unsigned i = 0; i < nTables; i++){
		
		ndbout << "Creating " << szTableName[i] << "... " ;
		
		NDBT_Table tmpTable(szTableName[i]) ;
		
		tmpTable.setStoredTable(!theTempTable) ;
    
  		tmpTable.addAttribute(NDBT_Attribute(attrName[0],
                                    UnSigned,
                                    4, // 4 Bytes
                                    TupleKey));
	}

		
	for (int j = 1 ; j < nNoOfCol ; j++)
		tmpTable.addAttribute(NDBT_Attribute(attrName[j], UnSigned, 4*tAttributeSize)) ;

	if(tmpTable.createTableInDb(pMyNdb) == -1){
		return -1 ;
	}
    
	ndbout << "done" << endl ;
		
	return 0;
}
*/

/*************************************************
Function: createTables()
Uses NDB API to create tables for the tests
*************************************************/

int createTables(char* szTableName, int nTables){

  Ndb * pNdb = new Ndb("TEST_DB") ;
  pNdb->init();
  
  ndbout << "Waiting for ndb to become ready..." <<endl;
  if (pNdb->waitUntilReady(10000) != 0){
    ndbout << "NDB is not ready" << endl;
    ndbout << "Benchmark failed!" << endl;
    delete pNdb ;
	return -1 ;
  }

  NdbSchemaCon          *MySchemaTransaction = NULL ;
  NdbSchemaOp           *MySchemaOp = NULL ;
  int                   check = -1 ;
  char					szColNameBuffer[MAX_COL_NAME] = { 0 } ;
  int					tLoadFactor = 80 ;
  
  for(int i=0 ; i < nTables ; ++i) {
	  
	  ndbout << "Creating " << (char*)(szTableName+MAX_TABLE_NAME*i) << "..." << endl ;

      MySchemaTransaction = pNdb->startSchemaTransaction() ;
	  //printf("MySchemaTransaction - OK\n") ;
      if(MySchemaTransaction == NULL){
		  printf("MySchemaTransaction is NULL\n") ;
		  delete pNdb ;
		  return -1 ;
	  }
      
      MySchemaOp = MySchemaTransaction->getNdbSchemaOp();       
  	  //printf("MySchemaTransaction->getNdb... - OK\n") ;
      if(MySchemaOp == NULL){
  		  printf("MySchemaOp is NULL\n") ;
		  delete pNdb ;
		  return -1 ;
	  }
      
      check = MySchemaOp->createTable( (const char*)(szTableName+MAX_TABLE_NAME*i)
                                       ,8                       // Table Size
                                       ,TupleKey                // Key Type
                                       ,40                      // Nr of Pages
                                       ,All
                                       ,6
                                       ,(tLoadFactor - 5)
                                       ,(tLoadFactor)
                                       ,1
                                       ,0
                                       );
      
      if (check == -1){
 		  printf("MySchemaOp->createTable failed\n") ;
		  delete pNdb ;
		  return -1 ;
	  }

      snprintf(szColNameBuffer, MAX_COL_NAME, "COL%d", 0) ;
      check = MySchemaOp->createAttribute( szColNameBuffer,
                                           TupleKey,
                                           32,
                                           PKSIZE,
                                           UnSigned,
                                           MMBased,
                                           NotNullAttribute );
      
      if (check == -1){
  		  printf("MySchemaOp->createAttribute() #1 failed\n") ;
		  delete pNdb ;
		  return -1 ;
	  }

      for (int j = 1; j < nNoOfCol ; j++){
		  snprintf(szColNameBuffer, MAX_COL_NAME, "COL%d", j) ;
		  check = MySchemaOp->createAttribute(szColNameBuffer,
                                             NoKey,
                                             32,
                                             tAttributeSize,
                                             UnSigned,
                                             MMBased,
                                             NotNullAttribute );
		
		  if (check == -1){
    		  printf("MySchemaOp->createAttribute() #2 failed\n") ;
			  delete pNdb ;
			  return -1;
		  }
      }
      
      if (MySchemaTransaction->execute() == -1){
   		  printf("MySchemaTransaction->execute() failed\n") ;
		  printf("%s\n", MySchemaTransaction->getNdbError().message) ; 
		  return -1 ;
		  delete pNdb ;
	  }
      
      pNdb->closeSchemaTransaction(MySchemaTransaction);
    }
  
  return 0;
}