diff --git a/libmysql/libmysql.c b/libmysql/libmysql.c index d6d2dca9af0..9d87cef2e34 100644 --- a/libmysql/libmysql.c +++ b/libmysql/libmysql.c @@ -1739,7 +1739,6 @@ static void mysql_once_init() #define strdup_if_not_null(A) (A) == 0 ? 0 : my_strdup((A),MYF(MY_WME)) -#ifdef HAVE_OPENSSL my_bool STDCALL mysql_ssl_set(MYSQL *mysql __attribute__((unused)) , const char *key __attribute__((unused)), @@ -1748,14 +1747,15 @@ mysql_ssl_set(MYSQL *mysql __attribute__((unused)) , const char *capath __attribute__((unused)), const char *cipher __attribute__((unused))) { +#ifdef HAVE_OPENSSL mysql->options.ssl_key= strdup_if_not_null(key); mysql->options.ssl_cert= strdup_if_not_null(cert); mysql->options.ssl_ca= strdup_if_not_null(ca); mysql->options.ssl_capath= strdup_if_not_null(capath); mysql->options.ssl_cipher= strdup_if_not_null(cipher); +#endif /* HAVE_OPENSSL */ return 0; } -#endif /************************************************************************** @@ -3927,27 +3927,8 @@ mysql_prepare(MYSQL *mysql, const char *query, ulong length) /* Returns prepared meta information in the form of resultset to client. -TODO : Return param information also */ -MYSQL_RES *prepare_result(MYSQL_FIELD *fields, unsigned long count) -{ - MYSQL_RES *result; - - if (!count || !fields) - return 0; - - if (!(result=(MYSQL_RES*) my_malloc(sizeof(*result)+ - sizeof(ulong)*count, - MYF(MY_WME | MY_ZEROFILL)))) - return 0; - - result->eof=1; /* Marker for buffered */ - result->fields= fields; - result->field_count= count; - return result; -} - MYSQL_RES * STDCALL mysql_prepare_result(MYSQL_STMT *stmt) { @@ -4430,6 +4411,327 @@ mysql_send_long_data(MYSQL_STMT *stmt, uint param_number, ****************************************************************************/ +static ulong get_field_length(uint type) +{ + ulong length; + + switch (type) { + + case MYSQL_TYPE_TINY: + length= 1; + break; + case MYSQL_TYPE_SHORT: + case MYSQL_TYPE_YEAR: + length= 2; + break; + case MYSQL_TYPE_LONG: + case MYSQL_TYPE_FLOAT: + length= 4; + break; + case MYSQL_TYPE_LONGLONG: + case MYSQL_TYPE_DOUBLE: + length= 8; + break; + default: + length= 0; + } + return length; +} + +static void send_data_long(MYSQL_BIND *param, longlong value) +{ + char *buffer= param->buffer; + + *param->length= get_field_length(param->buffer_type); + switch(param->buffer_type) { + + case MYSQL_TYPE_TINY: + *param->buffer= (uchar) value; + break; + case MYSQL_TYPE_SHORT: + int2store(buffer, (short)value); + break; + case MYSQL_TYPE_LONG: + int4store(buffer, (int32)value); + break; + case MYSQL_TYPE_LONGLONG: + int8store(buffer, (longlong)value); + break; + case MYSQL_TYPE_FLOAT: + { + float data= (float)value; + float4store(buffer, data); + break; + } + case MYSQL_TYPE_DOUBLE: + { + double data= (double)value; + float8store(buffer, data); + break; + } + default: + { + uint length= sprintf(buffer,"%lld",value); + *param->length= length; + buffer[length]='\0'; + } + } +} + +static void send_data_double(MYSQL_BIND *param, double value) +{ + char *buffer= param->buffer; + + *param->length= get_field_length(param->buffer_type); + switch(param->buffer_type) { + + case MYSQL_TYPE_TINY: + *buffer= (uchar)value; + break; + case MYSQL_TYPE_SHORT: + int2store(buffer, (short)value); + break; + case MYSQL_TYPE_LONG: + int4store(buffer, (int32)value); + break; + case MYSQL_TYPE_LONGLONG: + int8store(buffer, (longlong)value); + break; + case MYSQL_TYPE_FLOAT: + { + float data= (float)value; + float4store(buffer, data); + break; + } + case MYSQL_TYPE_DOUBLE: + { + double data= (double)value; + float8store(buffer, data); + break; + } + default: + { + uint length= sprintf(buffer,"%g",value); + *param->length= length; + buffer[length]='\0'; + } + } +} + +static void send_data_str(MYSQL_BIND *param, char *value, uint src_length) +{ + char *buffer= param->buffer; + + *param->length= get_field_length(param->buffer_type); + switch(param->buffer_type) { + + case MYSQL_TYPE_TINY: + *buffer= (char)*value; + break; + case MYSQL_TYPE_SHORT: + { + short data= (short)sint2korr(value); + int2store(buffer, data); + break; + } + case MYSQL_TYPE_LONG: + { + int32 data= (int32)sint4korr(value); + int4store(buffer, data); + break; + } + case MYSQL_TYPE_LONGLONG: + { + longlong data= sint8korr(value); + int8store(buffer, data); + break; + } + case MYSQL_TYPE_FLOAT: + { + float data; + float4get(data, value); + float4store(buffer, data); + break; + } + case MYSQL_TYPE_DOUBLE: + { + double data; + float8get(data, value); + float8store(buffer, data); + break; + } + default: + *param->length= src_length; + memcpy(buffer, value, src_length); + buffer[src_length]='\0'; + } +} + +static my_bool fetch_results(MYSQL_STMT *stmt, MYSQL_BIND *param, + uint field_type, uchar **row) +{ + ulong length; + + length= get_field_length(field_type); + switch (field_type) { + + case MYSQL_TYPE_TINY: + { + uchar value= (uchar) **row; + send_data_long(param,(longlong)value); + break; + } + case MYSQL_TYPE_SHORT: + case MYSQL_TYPE_YEAR: + { + short value= (short)sint2korr(*row); + send_data_long(param,(longlong)value); + break; + } + case MYSQL_TYPE_LONG: + { + int32 value= (int32)sint4korr(*row); + send_data_long(param,(int32)value); + break; + } + case MYSQL_TYPE_LONGLONG: + { + longlong value= (longlong)sint8korr(*row); + send_data_long(param,value); + break; + } + case MYSQL_TYPE_FLOAT: + { + float value; + float4get(value,*row); + send_data_double(param,(double)value); + break; + } + case MYSQL_TYPE_DOUBLE: + { + double value; + float8get(value,*row); + send_data_double(param,(double)value); + break; + } + case MYSQL_TYPE_DATE: + case MYSQL_TYPE_DATETIME: + case MYSQL_TYPE_TIMESTAMP: + { + uchar month,day; + short year; + int arg_length; + char ts[50],frac[10],time[20],date[20]; + + if (!(length= net_field_length(row))) + { + *param->length= 0; + break; + } + if (param->buffer_type < MYSQL_TYPE_VAR_STRING || + param->buffer_type > MYSQL_TYPE_STRING) + { + /* + Don't allow fetching of date/time/ts to non-string types + TODO: Allow fetching of date or time to long types. + */ + sprintf(stmt->last_error, + ER(stmt->last_errno= CR_UNSUPPORTED_PARAM_TYPE), + param->buffer_type, param->param_number); + return 1; + } + + arg_length= 0; + if (length > 7) + { + int sec_part= sint4korr(*row+7); + sprintf(frac,".%04d", sec_part); + arg_length+= 5; + } + if (length == 7) + { + uchar hour, minute, sec; + hour= *(*row+4); + minute= *(*row+5); + sec= *(*row+6); + sprintf((char *)time," %02d:%02d:%02d",hour,minute,sec); + arg_length+= 9; + } + + year= sint2korr(*row); + month= *(*row+2); + day= *(*row+3); + sprintf((char*) date,"%04d-%02d-%02d",year,month,day); + arg_length+= 10; + + if (arg_length != 19) + time[0]='\0'; + if (arg_length != 24) + frac[0]='\0'; + + strxmov(ts,date,time,frac,NullS); + send_data_str(param,ts,arg_length); + break; + } + case MYSQL_TYPE_TIME: + { + int day, arg_length; + uchar hour, minute, sec; + char ts[255], frac[20], time[20]; + const char *sign= ""; + + if (!(length= net_field_length(row))) + { + *param->length= 0; + break; + } + if (param->buffer_type < MYSQL_TYPE_VAR_STRING || + param->buffer_type > MYSQL_TYPE_STRING) + { + /* + Don't allow fetching of date/time/ts to non-string types + + TODO: Allow fetching of time to long types without + any conversion. + */ + sprintf(stmt->last_error, + ER(stmt->last_errno= CR_UNSUPPORTED_PARAM_TYPE), + param->buffer_type, param->param_number); + return 1; + } + arg_length= 0; + if (length > 8) + { + int sec_part= sint4korr(*row+8); + sprintf(frac,".%04d", sec_part); + arg_length+= 5; + } + + if (**row) + sign="-"; + + day= sint4korr(*row); /* TODO: how to handle this case */ + hour= *(*row+5); + minute= *(*row+6); + sec= *(*row+7); + arg_length+= sprintf((char *)time,"%s%02d:%02d:%02d",sign,hour,minute,sec); + + if (arg_length <= 9) + frac[0]='\0'; + + strxmov(ts,time,frac,NullS); + send_data_str(param,ts,arg_length); + break; + } + default: + length= net_field_length(row); + send_data_str(param,*row,length); + break; + } + *row+= length; + return 0; +} + static void fetch_result_tinyint(MYSQL_BIND *param, uchar **row) { *param->buffer= (uchar) **row; @@ -4438,23 +4740,23 @@ static void fetch_result_tinyint(MYSQL_BIND *param, uchar **row) static void fetch_result_short(MYSQL_BIND *param, uchar **row) { - short value= (short)**row; - int2store(param->buffer, value); - *row+=2; + short value = (short)sint2korr(*row); + int2store(param->buffer, value); + *row+= 2; } static void fetch_result_int32(MYSQL_BIND *param, uchar **row) { - int32 value= (int32)**row; + int32 value= (int32)sint4korr(*row); int4store(param->buffer, value); - *row+=4; + *row+= 4; } static void fetch_result_int64(MYSQL_BIND *param, uchar **row) -{ - longlong value= (longlong)**row; +{ + longlong value= (longlong)sint8korr(*row); int8store(param->buffer, value); - *row+=8; + *row+= 8; } static void fetch_result_float(MYSQL_BIND *param, uchar **row) @@ -4462,7 +4764,7 @@ static void fetch_result_float(MYSQL_BIND *param, uchar **row) float value; float4get(value,*row); float4store(param->buffer, value); - *row+=4; + *row+= 4; } static void fetch_result_double(MYSQL_BIND *param, uchar **row) @@ -4470,16 +4772,16 @@ static void fetch_result_double(MYSQL_BIND *param, uchar **row) double value; float8get(value,*row); float8store(param->buffer, value); - *row+=8; + *row+= 8; } static void fetch_result_str(MYSQL_BIND *param, uchar **row) { ulong length= net_field_length(row); memcpy(param->buffer, (char *)*row, length); - *(param->buffer+length)= '\0'; /* do we need this for all cases.. I doubt */ + *(param->buffer+length)= '\0'; *param->length= length; - *row+=length; + *row+= length; } /* @@ -4535,9 +4837,10 @@ my_bool STDCALL mysql_bind_result(MYSQL_STMT *stmt, MYSQL_BIND *bind) case MYSQL_TYPE_TINY_BLOB: case MYSQL_TYPE_MEDIUM_BLOB: case MYSQL_TYPE_LONG_BLOB: + case MYSQL_TYPE_BLOB: case MYSQL_TYPE_VAR_STRING: case MYSQL_TYPE_STRING: - param->length= ¶m->buffer_length; + param->bind_length= 0; param->fetch_result= fetch_result_str; break; default: @@ -4560,7 +4863,7 @@ static void stmt_fetch_row(MYSQL_STMT *stmt, uchar *row) { MYSQL_BIND *bind, *end; - MYSQL_FIELD *field; + MYSQL_FIELD *field, *field_end; uchar *null_ptr, bit; null_ptr= row; @@ -4569,15 +4872,20 @@ stmt_fetch_row(MYSQL_STMT *stmt, uchar *row) /* Copy complete row to application buffers */ for (bind= stmt->bind, end= (MYSQL_BIND *) bind + stmt->field_count, - field= stmt->fields; - bind < end && field; + field= stmt->fields, + field_end= (MYSQL_FIELD *)stmt->fields+stmt->field_count; + bind < end && field < field_end; bind++, field++) { if (*null_ptr & bit) *bind->length= MYSQL_NULL_DATA; else - /* TODO: Add conversion routines code here */ - (*bind->fetch_result)(bind, &row); + { + if (field->type == bind->buffer_type) + (*bind->fetch_result)(bind, &row); + else if (fetch_results(stmt, bind, field->type, &row)) + break; + } if (! (bit<<=1) & 255) { bit= 1; /* To next byte */ diff --git a/sql/field.cc b/sql/field.cc index 13bf50a91f5..0813c1fc6cc 100644 --- a/sql/field.cc +++ b/sql/field.cc @@ -3256,9 +3256,7 @@ int Field_year::store(longlong nr) bool Field_year::send_binary(Protocol *protocol) { ulonglong tmp= Field_year::val_int(); - TIME tm; - tm.year= (uint32) tmp; - return protocol->store_date(&tm); + return protocol->store_short(tmp); } double Field_year::val_real(void) diff --git a/sql/protocol.cc b/sql/protocol.cc index 63bca9b70b3..d7cf9d39b5c 100644 --- a/sql/protocol.cc +++ b/sql/protocol.cc @@ -852,7 +852,8 @@ bool Protocol_prep::store_short(longlong from) { #ifndef DEBUG_OFF DBUG_ASSERT(field_types == 0 || - field_types[field_pos] == MYSQL_TYPE_SHORT); + field_types[field_pos] == MYSQL_TYPE_SHORT || + field_types[field_pos] == MYSQL_TYPE_YEAR); #endif field_pos++; char *to= packet->prep_append(2, PACKET_BUFFET_EXTRA_ALLOC); @@ -939,7 +940,6 @@ bool Protocol_prep::store(TIME *tm) { #ifndef DEBUG_OFF DBUG_ASSERT(field_types == 0 || - field_types[field_pos] == MYSQL_TYPE_YEAR || field_types[field_pos] == MYSQL_TYPE_DATETIME || field_types[field_pos] == MYSQL_TYPE_DATE || field_types[field_pos] == MYSQL_TYPE_TIMESTAMP); @@ -950,11 +950,11 @@ bool Protocol_prep::store(TIME *tm) pos= buff+1; int2store(pos, tm->year); - int2store(pos+2, tm->month); - int2store(pos+3, tm->day); - int2store(pos+4, tm->hour); - int2store(pos+5, tm->minute); - int2store(pos+6, tm->second); + pos[2]= (uchar) tm->month; + pos[3]= (uchar) tm->day; + pos[4]= (uchar) tm->hour; + pos[5]= (uchar) tm->minute; + pos[6]= (uchar) tm->second; int4store(pos+7, tm->second_part); if (tm->second_part) length=11; @@ -987,15 +987,15 @@ bool Protocol_prep::store_time(TIME *tm) field_pos++; pos= buff+1; pos[0]= tm->neg ? 1 : 0; - int4store(pos+1, tm->day); - int2store(pos+5, tm->hour); - int2store(pos+7, tm->minute); - int2store(pos+9, tm->second); - int4store(pos+11, tm->second_part); + int4store(pos+1, tm->day); + pos[5]= (uchar) tm->hour; + pos[6]= (uchar) tm->minute; + pos[7]= (uchar) tm->second; + int4store(pos+8, tm->second_part); if (tm->second_part) - length=14; + length=11; else if (tm->hour || tm->minute || tm->second || tm->day) - length=10; + length=8; else length=0; buff[0]=(char) length; // Length is stored first diff --git a/tests/client_test.c b/tests/client_test.c index 280df2bf717..d5e13dd3b43 100644 --- a/tests/client_test.c +++ b/tests/client_test.c @@ -32,14 +32,13 @@ #include #include -#include - - /* mysql client headers */ #include #include #include +#include + #ifndef true #define true 1 #endif @@ -58,100 +57,119 @@ static char *opt_user=0; static char *opt_password=0; static char *opt_host=0; static char *opt_unix_socket=0; -static uint opt_port; +static unsigned int opt_port; static my_bool tty_password=0; static MYSQL *mysql=0; -static char query[255]; +static char query[255]; +static char current_db[]= "client_test_db"; -#define myheader(str) { printf("\n\n#######################\n"); \ - printf("%s",str); \ - printf("\n#######################\n"); \ +#define myheader(str) { fprintf(stdout,"\n\n#######################\n"); \ + fprintf(stdout,"%s",str); \ + fprintf(stdout,"\n#######################\n"); \ } #define init_bind(x) (bzero(x,sizeof(x))) -void print_error(const char *msg) +#ifndef mysql_param_result +#define mysql_param_result mysql_prepare_result +#endif + +static void print_error(const char *msg) { if (mysql) { - fprintf(stderr,"\n [MySQL]%s \n",mysql_error(mysql)); + if (mysql->server_version) + fprintf(stderr,"\n [MySQL-%s]",mysql->server_version); + else + fprintf(stderr,"\n [MySQL]"); + fprintf(stderr," %s\n",mysql_error(mysql)); } - else if(msg) fprintf(stderr, "%s\n", msg); + else if(msg) fprintf(stderr, " [MySQL] %s\n", msg); } -void print_st_error(MYSQL_STMT *stmt, const char *msg) +static void print_st_error(MYSQL_STMT *stmt, const char *msg) { if (stmt) { - fprintf(stderr,"\n [MySQL]%s \n",mysql_stmt_error(stmt)); + if (stmt->mysql && stmt->mysql->server_version) + fprintf(stderr,"\n [MySQL-%s]",stmt->mysql->server_version); + else + fprintf(stderr,"\n [MySQL]"); + + fprintf(stderr," %s\n",mysql_stmt_error(stmt)); } - else if(msg) fprintf(stderr, "%s\n", msg); + else if(msg) fprintf(stderr, " [MySQL] %s\n", msg); } +static void client_disconnect(); #define myerror(msg) print_error(msg) #define mysterror(stmt, msg) print_st_error(stmt, msg) -#define myassert(x) if(x) {\ - fprintf(stderr,"ASSERTION FAILED AT %d@%s\n",__LINE__, __FILE__);\ - exit(1);\ +#define myassert(exp) \ + if(!exp) {\ + client_disconnect(); \ + fprintf(stderr,"\n"); \ + assert(exp); \ } -#define myassert_r(x) if(!x) {\ - fprintf(stderr,"ASSERTION FAILED AT %d@%s\n",__LINE__, __FILE__);\ - exit(1);\ +#define myassert_r(exp) \ + if(exp) {\ + client_disconnect(); \ + fprintf(stderr,"\n"); \ + assert(!(exp)); \ } #define myquery(r) \ -if( r != 0) \ { \ +if( r || r == -1) \ myerror(NULL); \ - myassert(true);\ + myassert(r == 0); \ } #define myquery_r(r) \ -if( r != 0) \ { \ +if( r || r == -1) \ myerror(NULL); \ - myassert_r(true);\ +myassert_r(r == 0); \ } #define mystmt(stmt,r) \ -if( r != 0) \ { \ +if( r || r == -1) \ mysterror(stmt,NULL); \ - myassert(true);\ +myassert(r == 0);\ } -#define myxquery(stmt) \ -if( stmt == 0) \ -{ \ - myerror(NULL); \ - myassert(true);\ -} - -#define myxquery_r(stmt) \ -if( stmt == 0) \ -{ \ - myerror(NULL); \ - myassert_r(true);\ -} \ -else myassert(true); - #define mystmt_r(stmt,r) \ -if( r != 0) \ { \ +if( r || r == -1) \ mysterror(stmt,NULL); \ - myassert_r(true);\ +myassert_r(r == 0);\ } +#define mystmt_init(stmt) \ +{ \ +if( stmt == 0) \ + myerror(NULL); \ +myassert(stmt != 0); \ +} + +#define mystmt_init_r(stmt) \ +{ \ +myassert(stmt == 0);\ +} + #define mytest(x) if(!x) {myerror(NULL);myassert(true);} #define mytest_r(x) if(x) {myerror(NULL);myassert(true);} +#define PREPARE(A,B) mysql_prepare(A,B,strlen(B)) + /******************************************************** * connect to the server * *********************************************************/ static void client_connect() { + char buff[255]; myheader("client_connect"); if(!(mysql = mysql_init(NULL))) @@ -163,28 +181,37 @@ static void client_connect() opt_password, opt_db ? opt_db:"test", opt_port, opt_unix_socket, 0))) { - myerror("connection failed"); + myerror("connection failed"); + mysql_close(mysql); exit(0); } /* set AUTOCOMMIT to ON*/ mysql_autocommit(mysql, true); + sprintf(buff,"CREATE DATABASE IF NOT EXISTS %s", current_db); + mysql_query(mysql, buff); + sprintf(buff,"USE %s", current_db); + mysql_query(mysql, buff); } /******************************************************** * close the connection * *********************************************************/ -void client_disconnect() +static void client_disconnect() { - myheader("client_disconnect"); - - mysql_close(mysql); + if (mysql) + { + char buff[255]; + sprintf(buff,"DROP DATABASE IF EXISTS %s", current_db); + mysql_query(mysql, buff); + mysql_close(mysql); + } } /******************************************************** * query processing * *********************************************************/ -void client_query() +static void client_query() { int rc; @@ -222,7 +249,7 @@ void client_query() /******************************************************** * print dashes * *********************************************************/ -void my_print_dashes(MYSQL_RES *result) +static void my_print_dashes(MYSQL_RES *result) { MYSQL_FIELD *field; unsigned int i,j; @@ -244,7 +271,7 @@ void my_print_dashes(MYSQL_RES *result) /******************************************************** * print resultset metadata information * *********************************************************/ -void my_print_result_metadata(MYSQL_RES *result) +static void my_print_result_metadata(MYSQL_RES *result) { MYSQL_FIELD *field; unsigned int i,j; @@ -287,6 +314,9 @@ int my_process_result_set(MYSQL_RES *result) MYSQL_FIELD *field; unsigned int i; unsigned int row_count=0; + + if (!result) + return 0; my_print_result_metadata(result); @@ -313,50 +343,157 @@ int my_process_result_set(MYSQL_RES *result) my_print_dashes(result); if (mysql_errno(mysql) != 0) - fprintf(stderr, "\n\tmysql_fetch_row() failed\n"); + fprintf(stderr, "\n mysql_fetch_row() failed\n"); else - fprintf(stdout,"\n\t%d rows returned\n", row_count); + fprintf(stdout,"\n %d rows returned", row_count); return(row_count); } -static void verify_col_data(const char *table, const char *col, const char *exp_data) +/******************************************************** +* process the stmt result set * +*********************************************************/ +uint my_process_stmt_result(MYSQL_STMT *stmt) { - MYSQL_STMT *stmt; - MYSQL_BIND bind[1]; - char data[255]; - int rc; + int field_count; + uint row_count= 0; + MYSQL_BIND buffer[50]; + MYSQL_FIELD *field; + MYSQL_RES *result; + char data[50][255]; + long length[50]; + int rc, i; + + if (!(result= mysql_prepare_result(stmt))) + { + while (!mysql_fetch(stmt)); + return 0; + } - init_bind(bind); - - bind[0].buffer_type=FIELD_TYPE_STRING; - bind[0].buffer= (char *)data; - bind[0].buffer_length= sizeof(data); + field_count= stmt->field_count; + for(i=0; i < field_count; i++) + { + buffer[i].buffer_type= MYSQL_TYPE_STRING; + buffer[i].buffer_length=50; + buffer[i].length=(long *)&length[i]; + buffer[i].buffer=(gptr)data[i]; + } - sprintf(query, "SELECT `%s` FROM `%s`", col, table); + my_print_result_metadata(result); - printf("\n %s", query); - stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); - - rc = mysql_bind_result(stmt,bind); - mystmt(stmt, rc); - - rc = mysql_execute(stmt); - mystmt(stmt, rc); - - rc = mysql_fetch(stmt); + rc= mysql_bind_result(stmt,buffer); mystmt(stmt,rc); - printf("\n data : %s (expected: %s)",data, exp_data); - assert(strcmp(data,exp_data)==0); + mysql_field_seek(result, 0); + while (mysql_fetch(stmt) == 0) + { + fputc('\t',stdout); + fputc('|',stdout); - mysql_stmt_close(stmt); + for (i=0; i < field_count; i++) + { + field = mysql_fetch_field(result); + if(length[i] == MYSQL_NULL_DATA) + fprintf(stdout, " %-*s |", (int) field->max_length, "NULL"); + else if (IS_NUM(field->type)) + fprintf(stdout, " %*s |", (int) field->max_length, data[i]); + else + fprintf(stdout, " %-*s |", (int) field->max_length, data[i]); + } + fputc('\t',stdout); + fputc('\n',stdout); + row_count++; + } + my_print_dashes(result); + fprintf(stdout,"\n %d rows returned", row_count); + mysql_free_result(result); + + return row_count; } +/* + Utility function to verify a particular column data +*/ +static void verify_col_data(const char *table, const char *col, + const char *exp_data) +{ + MYSQL_RES *result; + MYSQL_ROW row; + char query[255]; + int rc, field= 1; + + if (table && col) + { + sprintf(query, "SELECT %s FROM %s LIMIT 1", col, table); + + fprintf(stdout,"\n %s", query); + rc = mysql_query(mysql, query); + myquery(rc); + + field= 0; + } + + result = mysql_use_result(mysql); + mytest(result); + + if (!(row= mysql_fetch_row(result)) || !row[field]) + { + fprintf(stdout,"\n *** ERROR: FAILED TO GET THE RESULT ***"); + exit(1); + } + fprintf(stdout,"\n obtained: `%s` (expected: `%s`)", + row[field], exp_data); + myassert(strcmp(row[field],exp_data) == 0); + mysql_free_result(result); +} + +/* + Utility function to verify the field members +*/ + +static void verify_prepare_field(MYSQL_RES *result, + unsigned int no,const char *name, const char *org_name, + enum enum_field_types type, const char *table, + const char *org_table, const char *db) +{ + MYSQL_FIELD *field; + + if (!(field= mysql_fetch_field_direct(result,no))) + { + fprintf(stdout,"\n *** ERROR: FAILED TO GET THE RESULT ***"); + exit(1); + } + fprintf(stdout,"\n field[%d]:", no); + fprintf(stdout,"\n name :`%s`\t(expected: `%s`)", field->name, name); + fprintf(stdout,"\n org_name :`%s`\t(expected: `%s`)", field->org_name, org_name); + fprintf(stdout,"\n type :`%d`\t(expected: `%d`)", field->type, type); + fprintf(stdout,"\n table :`%s`\t(expected: `%s`)", field->table, table); + fprintf(stdout,"\n org_table:`%s`\t(expected: `%s`)", field->org_table, org_table); + fprintf(stdout,"\n database :`%s`\t(expected: `%s`)", field->db, db); + fprintf(stdout,"\n"); + myassert(strcmp(field->name,name) == 0); + myassert(strcmp(field->org_name,org_name) == 0); + myassert(field->type == type); + myassert(strcmp(field->table,table) == 0); + myassert(strcmp(field->org_table,org_table) == 0); + myassert(strcmp(field->db,db) == 0); +} + +/* + Utility function to verify the parameter count +*/ +static void verify_param_count(MYSQL_STMT *stmt, long exp_count) +{ + long param_count= mysql_param_count(stmt); + fprintf(stdout,"\n total parameters in stmt: %ld (expected: %ld)", + param_count, exp_count); + myassert(param_count == exp_count); +} + + /******************************************************** * store result processing * *********************************************************/ -void client_store_result() +static void client_store_result() { MYSQL_RES *result; int rc; @@ -375,9 +512,9 @@ void client_store_result() } /******************************************************** -* use result processing * +* fetch the results *********************************************************/ -void client_use_result() +static void client_use_result() { MYSQL_RES *result; int rc; @@ -398,7 +535,7 @@ void client_use_result() /******************************************************** * query processing * *********************************************************/ -void test_debug_example() +static void test_debug_example() { int rc; MYSQL_RES *result; @@ -418,7 +555,7 @@ void test_debug_example() rc = mysql_query(mysql,"UPDATE test_debug_example SET name='updated' WHERE name='deleted'"); myquery(rc); - rc = mysql_query(mysql,"SELECT * FROM test_debug_example"); + rc = mysql_query(mysql,"SELECT * FROM test_debug_example where name='mysql'"); myquery(rc); result = mysql_use_result(mysql); @@ -434,7 +571,7 @@ void test_debug_example() /******************************************************** * to test autocommit feature * *********************************************************/ -void test_tran_bdb() +static void test_tran_bdb() { MYSQL_RES *result; MYSQL_ROW row; @@ -512,7 +649,7 @@ void test_tran_bdb() /******************************************************** * to test autocommit feature * *********************************************************/ -void test_tran_innodb() +static void test_tran_innodb() { MYSQL_RES *result; MYSQL_ROW row; @@ -591,10 +728,10 @@ void test_tran_innodb() To test simple prepares of all DML statements *********************************************************/ -void test_prepare_simple() +static void test_prepare_simple() { MYSQL_STMT *stmt; - int rc,param_count; + int rc; myheader("test_prepare_simple"); @@ -610,41 +747,33 @@ void test_prepare_simple() /* alter table */ strcpy(query,"ALTER TABLE test_prepare_simple ADD new char(20)"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout,"\n total parameters in alter:%d\n", param_count); - assert(param_count == 0); + verify_param_count(stmt,0); mysql_stmt_close(stmt); /* insert */ strcpy(query,"INSERT INTO test_prepare_simple VALUES(?,?)"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout,"\n total parameters in insert:%d\n", param_count); - assert(param_count == 2); + verify_param_count(stmt,2); mysql_stmt_close(stmt); /* update */ strcpy(query,"UPDATE test_prepare_simple SET id=? WHERE id=? AND name= ?"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout,"\n total parameters in update:%d\n", param_count); - assert(param_count == 3); + verify_param_count(stmt,3); mysql_stmt_close(stmt); /* delete */ strcpy(query,"DELETE FROM test_prepare_simple WHERE id=10"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout,"\n total parameters in delete:%d\n", param_count); - assert(param_count == 0); + verify_param_count(stmt,0); rc = mysql_execute(stmt); mystmt(stmt, rc); @@ -653,11 +782,9 @@ void test_prepare_simple() /* delete */ strcpy(query,"DELETE FROM test_prepare_simple WHERE id=?"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout,"\n total parameters in delete:%d\n", param_count); - assert(param_count == 1); + verify_param_count(stmt,1); rc = mysql_execute(stmt); mystmt_r(stmt, rc); @@ -666,11 +793,9 @@ void test_prepare_simple() /* select */ strcpy(query,"SELECT * FROM test_prepare_simple WHERE id=? AND name= ?"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout,"\n total parameters in select:%d\n", param_count); - assert(param_count == 2); + verify_param_count(stmt,2); mysql_stmt_close(stmt); @@ -683,9 +808,10 @@ void test_prepare_simple() /******************************************************** * to test simple prepare field results * *********************************************************/ -void test_prepare_field_result() +static void test_prepare_field_result() { MYSQL_STMT *stmt; + MYSQL_RES *result; int rc,param_count; myheader("test_prepare_field_result"); @@ -696,29 +822,47 @@ void test_prepare_field_result() rc = mysql_commit(mysql); myquery(rc); - rc = mysql_query(mysql,"CREATE TABLE test_prepare_field_result(id int, name varchar(50), extra int)"); + rc = mysql_query(mysql,"CREATE TABLE test_prepare_field_result(int_c int, \ + var_c varchar(50), ts_c timestamp(14),\ + char_c char(3), date_c date,extra tinyint)"); myquery(rc); /* insert */ - strcpy(query,"SELECT id,name FROM test_prepare_field_result WHERE id=?"); + strcpy(query,"SELECT int_c,var_c,date_c as date,ts_c,char_c FROM \ + test_prepare_field_result as t1 WHERE int_c=?"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout,"\n total parameters in insert:%d\n", param_count); - assert(param_count == 1); + verify_param_count(stmt,1); + + result = mysql_prepare_result(stmt); + mytest(result); + + my_print_result_metadata(result); + + fprintf(stdout,"\n\n field attributes:\n"); + verify_prepare_field(result,0,"int_c","int_c",MYSQL_TYPE_LONG, + "t1","test_prepare_field_result",current_db); + verify_prepare_field(result,1,"var_c","var_c",MYSQL_TYPE_VAR_STRING, + "t1","test_prepare_field_result",current_db); + verify_prepare_field(result,2,"date","date_c",MYSQL_TYPE_DATE, + "t1","test_prepare_field_result",current_db); + verify_prepare_field(result,3,"ts_c","ts_c",MYSQL_TYPE_TIMESTAMP, + "t1","test_prepare_field_result",current_db); + verify_prepare_field(result,4,"char_c","char_c",MYSQL_TYPE_STRING, + "t1","test_prepare_field_result",current_db); + + param_count= mysql_num_fields(result); + fprintf(stdout,"\n\n total fields: `%d` (expected: `5`)", param_count); + myassert(param_count == 5); mysql_stmt_close(stmt); - - /* now fetch the results ..*/ - rc = mysql_commit(mysql); - myquery(rc); } /******************************************************** * to test simple prepare field results * *********************************************************/ -void test_prepare_syntax() +static void test_prepare_syntax() { MYSQL_STMT *stmt; int rc; @@ -736,11 +880,11 @@ void test_prepare_syntax() strcpy(query,"INSERT INTO test_prepare_syntax VALUES(?"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery_r(stmt); + mystmt_init_r(stmt); strcpy(query,"SELECT id,name FROM test_prepare_syntax WHERE id=? AND WHERE"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery_r(stmt); + mystmt_init_r(stmt); /* now fetch the results ..*/ rc = mysql_commit(mysql); @@ -751,10 +895,10 @@ void test_prepare_syntax() /******************************************************** * to test simple prepare * *********************************************************/ -void test_prepare() +static void test_prepare() { MYSQL_STMT *stmt; - int rc,param_count; + int rc; char query[200]; int int_data; char str_data[50]; @@ -779,7 +923,7 @@ void test_prepare() myquery(rc); rc = mysql_query(mysql,"CREATE TABLE my_prepare(col1 tinyint,\ - col2 varchar(50), col3 int,\ + col2 varchar(15), col3 int,\ col4 smallint, col5 bigint, \ col6 float, col7 double )"); myquery(rc); @@ -787,11 +931,9 @@ void test_prepare() /* insert by prepare */ strcpy(query,"INSERT INTO my_prepare VALUES(?,?,?,?,?,?,?)"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout," total parameters in insert:%d\n", param_count); - assert(param_count == 7); + verify_param_count(stmt,7); /* tinyint */ bind[0].buffer_type=FIELD_TYPE_TINY; @@ -852,7 +994,7 @@ void test_prepare() result = mysql_store_result(mysql); mytest(result); - assert((int)tiny_data == my_process_result_set(result)); + myassert((int)tiny_data == my_process_result_set(result)); mysql_free_result(result); } @@ -860,10 +1002,10 @@ void test_prepare() /******************************************************** * to test double comparision * *********************************************************/ -void test_double_compare() +static void test_double_compare() { MYSQL_STMT *stmt; - int rc,param_count; + int rc; char query[200],real_data[10], tiny_data; double double_data; MYSQL_RES *result; @@ -890,10 +1032,9 @@ void test_double_compare() strcpy(query, "UPDATE test_double_compare SET col1=100 WHERE col1 = ? AND col2 = ? AND COL3 = ?"); stmt = mysql_prepare(mysql,query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout," total parameters in update:%d\n", param_count); + verify_param_count(stmt,3); /* tinyint */ bind[0].buffer_type=FIELD_TYPE_TINY; @@ -916,7 +1057,7 @@ void test_double_compare() mystmt(stmt, rc); rc = (int)mysql_affected_rows(mysql); - printf("\n total affected rows:%d",rc); + fprintf(stdout,"\n total affected rows:%d",rc); mysql_stmt_close(stmt); @@ -932,21 +1073,17 @@ void test_double_compare() result = mysql_store_result(mysql); mytest(result); - assert((int)tiny_data == my_process_result_set(result)); + myassert((int)tiny_data == my_process_result_set(result)); mysql_free_result(result); - } - - - /******************************************************** * to test simple null * *********************************************************/ -void test_null() +static void test_null() { MYSQL_STMT *stmt; - int rc,param_count; + int rc; int nData=1; MYSQL_RES *result; MYSQL_BIND bind[2]; @@ -966,15 +1103,13 @@ void test_null() /* insert by prepare, wrong column name */ strcpy(query,"INSERT INTO test_null(col3,col2) VALUES(?,?)"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery_r(stmt); + mystmt_init_r(stmt); strcpy(query,"INSERT INTO test_null(col1,col2) VALUES(?,?)"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout," total parameters in insert:%d\n", param_count); - assert(param_count == 2); + verify_param_count(stmt,2); bind[0].is_null=1; bind[0].buffer_type=MYSQL_TYPE_NULL; @@ -1003,49 +1138,171 @@ void test_null() result = mysql_store_result(mysql); mytest(result); - assert(nData == my_process_result_set(result)); + myassert(nData == my_process_result_set(result)); mysql_free_result(result); } +/******************************************************** +* to test fetch null * +*********************************************************/ +static void test_fetch_null() +{ + MYSQL_STMT *stmt; + int rc; + const char query[100]; + int length[11], i, nData; + MYSQL_BIND bind[11]; + + myheader("test_fetch_null"); + + init_bind(bind); + rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_fetch_null"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + rc = mysql_query(mysql,"CREATE TABLE test_fetch_null(col1 tinyint, col2 smallint, \ + col3 int, col4 bigint, \ + col5 float, col6 double, \ + col7 date, col8 time, \ + col9 varbinary(10), \ + col10 varchar(50),\ + col11 char(20))"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + rc = mysql_query(mysql,"INSERT INTO test_fetch_null(col11) VALUES(1000)"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + /* fetch */ + for (i=0; i < 10; i++) + { + bind[i].buffer_type=FIELD_TYPE_LONG; + length[i]=99; + bind[i].length= (long *)&length[i]; + } + bind[i].buffer_type=FIELD_TYPE_LONG; + bind[i].buffer=(gptr)&nData; + + strcpy((char *)query , "SELECT * FROM test_fetch_null"); + stmt = mysql_prepare(mysql, query, strlen(query)); + mystmt_init(stmt); + + rc = mysql_bind_result(stmt,bind); + mystmt(stmt, rc); + + rc = mysql_execute(stmt); + mystmt(stmt, rc); + + rc = mysql_fetch(stmt); + mystmt(stmt,rc); + + for (i=0; i < 10; i++) + { + fprintf(stdout, "\n data[%d]: %s", i, length[i] == MYSQL_NULL_DATA ? "NULL" : "NOT NULL"); + myassert(length[i] == MYSQL_NULL_DATA); + } + fprintf(stdout, "\n data[%d]: %d", i, nData); + myassert(nData == 1000); + + rc = mysql_fetch(stmt); + myassert(rc == MYSQL_NO_DATA); + + mysql_stmt_close(stmt); +} /******************************************************** * to test simple select * *********************************************************/ -void test_select_simple() +static void test_select_version() { MYSQL_STMT *stmt; - int rc,length; + int rc; + const char query[100]; + + myheader("test_select_version"); + + strcpy((char *)query , "SELECT @@version"); + stmt = PREPARE(mysql, query); + mystmt_init(stmt); + + verify_param_count(stmt,0); + + rc = mysql_execute(stmt); + mystmt(stmt, rc); + + my_process_stmt_result(stmt); + mysql_stmt_close(stmt); +} + +/******************************************************** +* to test simple select * +*********************************************************/ +static void test_select_simple() +{ + MYSQL_STMT *stmt; + int rc; const char query[100]; - MYSQL_RES *result; myheader("test_select_simple"); /* insert by prepare */ strcpy((char *)query, "SHOW TABLES FROM mysql"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - length = mysql_param_count(stmt); - fprintf(stdout," total parameters in select:%d\n", length); - assert(length == 0); + verify_param_count(stmt,0); rc = mysql_execute(stmt); mystmt(stmt, rc); - /* get the result */ - result = mysql_store_result(mysql); - mytest(result); - - my_process_result_set(result); - mysql_free_result(result); - + my_process_stmt_result(stmt); mysql_stmt_close(stmt); +} -#if 0 - strcpy((char *)query , "SELECT @@ VERSION"); - length = strlen(query); - rc = mysql_query(mysql,query); +/******************************************************** +* to test simple select to debug * +*********************************************************/ +static void test_select_direct() +{ + int rc; + MYSQL_RES *result; + + myheader("test_select_direct"); + + rc = mysql_autocommit(mysql,true); + myquery(rc); + + rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_select"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + rc = mysql_query(mysql,"CREATE TABLE test_select(id int, id1 tinyint, \ + id2 float, \ + id3 double, \ + name varchar(50))"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + /* insert a row and commit the transaction */ + rc = mysql_query(mysql,"INSERT INTO test_select VALUES(10,5,2.3,4.5,'venu')"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + rc = mysql_query(mysql,"SELECT * FROM test_select"); myquery(rc); /* get the result */ @@ -1054,22 +1311,88 @@ void test_select_simple() my_process_result_set(result); mysql_free_result(result); -#endif } +/******************************************************** +* to test simple select with prepare * +*********************************************************/ +static void test_select_prepare() +{ + int rc, count; + MYSQL_STMT *stmt; + + myheader("test_select_prepare"); + + rc = mysql_autocommit(mysql,true); + myquery(rc); + + rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_select"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + rc = mysql_query(mysql,"CREATE TABLE test_select(id int, name varchar(50))"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + /* insert a row and commit the transaction */ + rc = mysql_query(mysql,"INSERT INTO test_select VALUES(10,'venu')"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + stmt = mysql_prepare(mysql,"SELECT * FROM test_select",50); + mystmt_init(stmt); + + rc = mysql_execute(stmt); + mystmt(stmt,rc); + + count= my_process_stmt_result(stmt); + + rc = mysql_query(mysql,"DROP TABLE test_select"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + rc = mysql_query(mysql,"CREATE TABLE test_select(id tinyint, id1 int, \ + id2 float, id3 float, \ + name varchar(50))"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + /* insert a row and commit the transaction */ + rc = mysql_query(mysql,"INSERT INTO test_select(id,id1,id2,name) VALUES(10,5,2.3,'venu')"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + stmt = mysql_prepare(mysql,"SELECT * FROM test_select",25); + mystmt_init(stmt); + + rc = mysql_execute(stmt); + mystmt(stmt,rc); + + my_process_stmt_result(stmt); +} /******************************************************** * to test simple select * *********************************************************/ -void test_select() +static void test_select() { MYSQL_STMT *stmt; - int rc,param_count=0; - char *szData=(char *)"updated-value"; + int rc; + char szData[25]; int nData=1; MYSQL_BIND bind[2]; - MYSQL_RES *result; - myheader("test_select"); @@ -1105,15 +1428,13 @@ void test_select() strcpy(query,"SELECT * FROM test_select WHERE id=? AND name=?"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout," total parameters in select:%d\n", param_count); - assert(param_count == 2); + verify_param_count(stmt,2); /* string data */ nData=10; - szData=(char *)"venu"; + strcpy(szData,(char *)"venu"); bind[1].buffer_type=FIELD_TYPE_STRING; bind[1].buffer=szData; bind[1].buffer_length=4; @@ -1126,28 +1447,50 @@ void test_select() rc = mysql_execute(stmt); mystmt(stmt, rc); + myassert( 1 == my_process_stmt_result(stmt)); + + mysql_stmt_close(stmt); +} + +/******************************************************** +* to test simple select show * +*********************************************************/ +static void test_select_show() +{ + MYSQL_STMT *stmt; + int rc; + MYSQL_RES *result; + + myheader("test_select_show"); + + mysql_autocommit(mysql,true); + + strcpy(query,"SELECT * FROM mysql.host"); + stmt = mysql_prepare(mysql, query, strlen(query)); + mystmt_init(stmt); + + verify_param_count(stmt,0); + + rc = mysql_execute(stmt); + mystmt(stmt, rc); + /* get the result */ result = mysql_store_result(mysql); mytest(result); - assert( 1 == my_process_result_set(result)); + my_process_result_set(result); mysql_free_result(result); mysql_stmt_close(stmt); - - /* bit complicated SELECT */ } - - - /******************************************************** * to test simple update * *********************************************************/ -void test_simple_update() +static void test_simple_update() { MYSQL_STMT *stmt; - int rc,param_count; + int rc; char szData[25]; int nData=1; MYSQL_RES *result; @@ -1175,7 +1518,7 @@ void test_simple_update() rc = mysql_query(mysql,"INSERT INTO test_update VALUES(1,'MySQL',100)"); myquery(rc); - assert(1 == mysql_affected_rows(mysql)); + myassert(1 == mysql_affected_rows(mysql)); rc = mysql_commit(mysql); myquery(rc); @@ -1183,11 +1526,9 @@ void test_simple_update() /* insert by prepare */ strcpy(query,"UPDATE test_update SET col2=? WHERE col1=?"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout," total parameters in update:%d\n", param_count); - assert(param_count == 2); + verify_param_count(stmt,2); nData=1; bind[0].buffer_type=FIELD_TYPE_STRING; @@ -1201,7 +1542,7 @@ void test_simple_update() rc = mysql_execute(stmt); mystmt(stmt, rc); - assert(1 == mysql_affected_rows(mysql)); + myassert(1 == mysql_affected_rows(mysql)); mysql_stmt_close(stmt); @@ -1217,7 +1558,7 @@ void test_simple_update() result = mysql_store_result(mysql); mytest(result); - assert(1 == my_process_result_set(result)); + myassert(1 == my_process_result_set(result)); mysql_free_result(result); } @@ -1225,10 +1566,10 @@ void test_simple_update() /******************************************************** * to test simple long data handling * *********************************************************/ -void test_long_data() +static void test_long_data() { MYSQL_STMT *stmt; - int rc,param_count, int_data=10; + int rc, int_data; char *data=NullS; MYSQL_RES *result; MYSQL_BIND bind[3]; @@ -1255,15 +1596,13 @@ void test_long_data() strcpy(query,"INSERT INTO test_long_data(col1,col2) VALUES(?)"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery_r(stmt); + mystmt_init_r(stmt); strcpy(query,"INSERT INTO test_long_data(col1,col2,col3) VALUES(?,?,?)"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout," total parameters in insert:%d\n", param_count); - assert(param_count == 3); + verify_param_count(stmt,3); bind[0].buffer=(char *)&int_data; bind[0].buffer_type=FIELD_TYPE_LONG; @@ -1272,7 +1611,7 @@ void test_long_data() /* Non string or binary type, error */ bind[1].buffer_type=FIELD_TYPE_LONG; rc = mysql_bind_param(stmt,bind); - fprintf(stdout,"mysql_bind_param() returned %d\n",rc); + fprintf(stdout," mysql_bind_param() returned: %d\n",rc); mystmt_r(stmt, rc); bind[1].buffer_type=FIELD_TYPE_STRING; @@ -1280,36 +1619,37 @@ void test_long_data() rc = mysql_bind_param(stmt,bind); mystmt(stmt, rc); + int_data= 999; rc = mysql_execute(stmt); - fprintf(stdout,"mysql_execute() returned %d\n",rc); - assert(rc == MYSQL_NEED_DATA); + fprintf(stdout," mysql_execute() returned %d\n",rc); + myassert(rc == MYSQL_NEED_DATA); data = (char *)"Micheal"; /* supply data in pieces */ - rc = mysql_send_long_data(stmt,1,data,7,1); + rc = mysql_send_long_data(stmt,1,data,7,0); mystmt(stmt, rc); /* try to execute mysql_execute() now, it should return MYSQL_NEED_DATA as the long data supply is not yet over */ rc = mysql_execute(stmt); - fprintf(stdout,"mysql_execute() returned %d\n",rc); - assert(rc == MYSQL_NEED_DATA); + fprintf(stdout," mysql_execute() returned %d\n",rc); + myassert(rc == MYSQL_NEED_DATA); /* append data again ..*/ /* Indicate end of data */ - data = (char *)" 'monty' widenius"; + data = (char *)" 'monty' Widenius"; rc = mysql_send_long_data(stmt,1,data,17,1); mystmt(stmt, rc); - rc = mysql_send_long_data(stmt,2,"Venu (venu@mysql.com",4,1); + rc = mysql_send_long_data(stmt,2,"Venu (venu@mysql.com)",4,1); mystmt(stmt, rc); /* execute */ rc = mysql_execute(stmt); - fprintf(stdout,"mysql_execute() returned %d\n",rc); + fprintf(stdout," mysql_execute() returned %d\n",rc); mystmt(stmt,rc); rc = mysql_commit(mysql); @@ -1323,17 +1663,21 @@ void test_long_data() result = mysql_store_result(mysql); mytest(result); - assert(1 == my_process_result_set(result)); + myassert(1 == my_process_result_set(result)); mysql_free_result(result); + + verify_col_data("test_long_data","col1","999"); + verify_col_data("test_long_data","col2","Micheal 'monty' Widenius"); + verify_col_data("test_long_data","col3","Venu"); } /******************************************************** * to test long data (string) handling * *********************************************************/ -void test_long_data_str() +static void test_long_data_str() { MYSQL_STMT *stmt; - int rc,param_count; + int rc, i; char data[255]; long length; MYSQL_RES *result; @@ -1360,11 +1704,9 @@ void test_long_data_str() strcpy(query,"INSERT INTO test_long_data_str VALUES(?,?)"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout," total parameters in insert:%d\n", param_count); - assert(param_count == 2); + verify_param_count(stmt,2); bind[0].buffer = (gptr)&length; bind[0].buffer_type = FIELD_TYPE_LONG; @@ -1377,28 +1719,24 @@ void test_long_data_str() length = 10; rc = mysql_execute(stmt); - fprintf(stdout,"mysql_execute() returned %d\n",rc); - assert(rc == MYSQL_NEED_DATA); + fprintf(stdout," mysql_execute() returned %d\n",rc); + myassert(rc == MYSQL_NEED_DATA); length = 40; sprintf(data,"MySQL AB"); /* supply data in pieces */ + for(i=0; i < 4; i++) { - int i; - for(i=0; i < 4; i++) - { - rc = mysql_send_long_data(stmt,1,(char *)data,5,0); - mystmt(stmt, rc); - } - - /* try to execute mysql_execute() now, it should return - MYSQL_NEED_DATA as the long data supply is not yet over - */ - rc = mysql_execute(stmt); - fprintf(stdout,"mysql_execute() returned %d\n",rc); - assert(rc == MYSQL_NEED_DATA); + rc = mysql_send_long_data(stmt,1,(char *)data,5,0); + mystmt(stmt, rc); } + /* try to execute mysql_execute() now, it should return + MYSQL_NEED_DATA as the long data supply is not yet over + */ + rc = mysql_execute(stmt); + fprintf(stdout," mysql_execute() returned %d\n",rc); + myassert(rc == MYSQL_NEED_DATA); /* Indiate end of data supply */ rc = mysql_send_long_data(stmt,1,0,0,1); @@ -1406,7 +1744,7 @@ void test_long_data_str() /* execute */ rc = mysql_execute(stmt); - fprintf(stdout,"mysql_execute() returned %d\n",rc); + fprintf(stdout," mysql_execute() returned %d\n",rc); mystmt(stmt,rc); mysql_stmt_close(stmt); @@ -1422,20 +1760,27 @@ void test_long_data_str() result = mysql_store_result(mysql); mytest(result); - assert(1 == my_process_result_set(result)); + myassert(1 == my_process_result_set(result)); mysql_free_result(result); + + sprintf(data,"%d", i*5); + verify_col_data("test_long_data_str","LENGTH(longstr)", data); + data[0]='\0'; + while (i--) + sprintf(data,"%s%s", data,"MySQL"); + verify_col_data("test_long_data_str","longstr", data); } /******************************************************** * to test long data (string) handling * *********************************************************/ -void test_long_data_str1() +static void test_long_data_str1() { MYSQL_STMT *stmt; - int rc,param_count; - char *data=(char *)"MySQL AB"; - int length; + int rc; + char data[255]; + int length, i; MYSQL_RES *result; MYSQL_BIND bind[2]; @@ -1460,11 +1805,9 @@ void test_long_data_str1() strcpy(query,"INSERT INTO test_long_data_str VALUES(?,?)"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout," total parameters in insert:%d\n", param_count); - assert(param_count == 2); + verify_param_count(stmt,2); bind[0].buffer=data; /* string data */ bind[0].is_long_data=1; /* specify long data suppy during run-time */ @@ -1478,44 +1821,41 @@ void test_long_data_str1() length = 10; rc = mysql_execute(stmt); - fprintf(stdout,"mysql_execute() returned %d\n",rc); - assert(rc == MYSQL_NEED_DATA); + fprintf(stdout," mysql_execute() returned %d\n",rc); + myassert(rc == MYSQL_NEED_DATA); - length = strlen(data); + length = sprintf(data,"MySQL AB"); /* supply data in pieces */ + for(i=0; i < 3; i++) { - int i; - for(i=0; i < 2; i++) - { - rc = mysql_send_long_data(stmt,0,data,length,0); - mystmt(stmt, rc); + rc = mysql_send_long_data(stmt,0,data,length,0); + mystmt(stmt, rc); - rc = mysql_send_long_data(stmt,1,data,2,0); - mystmt(stmt, rc); - } - /* try to execute mysql_execute() now, it should return - MYSQL_NEED_DATA as the long data supply is not yet over - */ - rc = mysql_execute(stmt); - fprintf(stdout,"mysql_execute() returned %d\n",rc); - assert(rc == MYSQL_NEED_DATA); + rc = mysql_send_long_data(stmt,1,data,2,0); + mystmt(stmt, rc); } - + /* try to execute mysql_execute() now, it should return + MYSQL_NEED_DATA as the long data supply is not yet over + */ + rc = mysql_execute(stmt); + fprintf(stdout," mysql_execute() returned %d\n",rc); + myassert(rc == MYSQL_NEED_DATA); + /* Indiate end of data supply */ rc = mysql_send_long_data(stmt,1,0,0,1); mystmt(stmt, rc); rc = mysql_execute(stmt); - fprintf(stdout,"mysql_execute() returned %d\n",rc); - assert(rc == MYSQL_NEED_DATA); + fprintf(stdout," mysql_execute() returned %d\n",rc); + myassert(rc == MYSQL_NEED_DATA); rc = mysql_send_long_data(stmt,0,0,0,1); mystmt(stmt, rc); /* execute */ rc = mysql_execute(stmt); - fprintf(stdout,"mysql_execute() returned %d\n",rc); + fprintf(stdout," mysql_execute() returned %d\n",rc); mystmt(stmt,rc); mysql_stmt_close(stmt); @@ -1531,18 +1871,24 @@ void test_long_data_str1() result = mysql_store_result(mysql); mytest(result); - assert(1 == my_process_result_set(result)); + myassert(1 == my_process_result_set(result)); mysql_free_result(result); + + sprintf(data,"%d",i*length); + verify_col_data("test_long_data_str","length(longstr)",data); + + sprintf(data,"%d",i*2); + verify_col_data("test_long_data_str","length(blb)",data); } /******************************************************** * to test long data (binary) handling * *********************************************************/ -void test_long_data_bin() +static void test_long_data_bin() { MYSQL_STMT *stmt; - int rc,param_count; + int rc; char data[255]; int length; MYSQL_RES *result; @@ -1569,11 +1915,9 @@ void test_long_data_bin() strcpy(query,"INSERT INTO test_long_data_bin VALUES(?,?)"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout," total parameters in insert:%d\n", param_count); - assert(param_count == 2); + verify_param_count(stmt,2); bind[0].buffer = (gptr)&length; bind[0].buffer_type = FIELD_TYPE_LONG; @@ -1586,8 +1930,8 @@ void test_long_data_bin() length = 10; rc = mysql_execute(stmt); - fprintf(stdout,"mysql_execute() returned %d\n",rc); - assert(rc == MYSQL_NEED_DATA); + fprintf(stdout," mysql_execute() returned %d\n",rc); + myassert(rc == MYSQL_NEED_DATA); sprintf(data,"MySQL AB"); @@ -1604,8 +1948,8 @@ void test_long_data_bin() MYSQL_NEED_DATA as the long data supply is not yet over */ rc = mysql_execute(stmt); - fprintf(stdout,"mysql_execute() returned %d\n",rc); - assert(rc == MYSQL_NEED_DATA); + fprintf(stdout," mysql_execute() returned %d\n",rc); + myassert(rc == MYSQL_NEED_DATA); } /* Indiate end of data supply */ @@ -1614,7 +1958,7 @@ void test_long_data_bin() /* execute */ rc = mysql_execute(stmt); - fprintf(stdout,"mysql_execute() returned %d\n",rc); + fprintf(stdout," mysql_execute() returned %d\n",rc); mystmt(stmt,rc); mysql_stmt_close(stmt); @@ -1630,7 +1974,7 @@ void test_long_data_bin() result = mysql_store_result(mysql); mytest(result); - assert(1 == my_process_result_set(result)); + myassert(1 == my_process_result_set(result)); mysql_free_result(result); } @@ -1638,10 +1982,10 @@ void test_long_data_bin() /******************************************************** * to test simple delete * *********************************************************/ -void test_simple_delete() +static void test_simple_delete() { MYSQL_STMT *stmt; - int rc,param_count; + int rc; char szData[30]={0}; int nData=1; MYSQL_RES *result; @@ -1670,7 +2014,7 @@ void test_simple_delete() rc = mysql_query(mysql,"INSERT INTO test_simple_delete VALUES(1,'MySQL',100)"); myquery(rc); - assert(1 == mysql_affected_rows(mysql)); + myassert(1 == mysql_affected_rows(mysql)); rc = mysql_commit(mysql); myquery(rc); @@ -1678,11 +2022,9 @@ void test_simple_delete() /* insert by prepare */ strcpy(query,"DELETE FROM test_simple_delete WHERE col1=? AND col2=? AND col3=100"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout," total parameters in delete:%d\n", param_count); - assert(param_count == 2); + verify_param_count(stmt,2); nData=1; strcpy(szData,"MySQL"); @@ -1697,7 +2039,7 @@ void test_simple_delete() rc = mysql_execute(stmt); mystmt(stmt, rc); - assert(1 == mysql_affected_rows(mysql)); + myassert(1 == mysql_affected_rows(mysql)); mysql_stmt_close(stmt); @@ -1713,7 +2055,7 @@ void test_simple_delete() result = mysql_store_result(mysql); mytest(result); - assert(0 == my_process_result_set(result)); + myassert(0 == my_process_result_set(result)); mysql_free_result(result); } @@ -1722,10 +2064,10 @@ void test_simple_delete() /******************************************************** * to test simple update * *********************************************************/ -void test_update() +static void test_update() { MYSQL_STMT *stmt; - int rc,param_count; + int rc; char szData[25]; int nData=1; MYSQL_RES *result; @@ -1753,11 +2095,9 @@ void test_update() strcpy(query,"INSERT INTO test_update(col2,col3) VALUES(?,?)"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout," total parameters in insert:%d\n", param_count); - assert(param_count == 2); + verify_param_count(stmt,2); /* string data */ bind[0].buffer_type=FIELD_TYPE_STRING; @@ -1773,16 +2113,14 @@ void test_update() rc = mysql_execute(stmt); mystmt(stmt, rc); - assert(1 == mysql_affected_rows(mysql)); + myassert(1 == mysql_affected_rows(mysql)); mysql_stmt_close(stmt); strcpy(query,"UPDATE test_update SET col2=? WHERE col3=?"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout," total parameters in update:%d\n", param_count); - assert(param_count == 2); + verify_param_count(stmt,2); nData=100; @@ -1797,7 +2135,7 @@ void test_update() rc = mysql_execute(stmt); mystmt(stmt, rc); - assert(1 == mysql_affected_rows(mysql)); + myassert(1 == mysql_affected_rows(mysql)); mysql_stmt_close(stmt); @@ -1813,7 +2151,7 @@ void test_update() result = mysql_store_result(mysql); mytest(result); - assert(1 == my_process_result_set(result)); + myassert(1 == my_process_result_set(result)); mysql_free_result(result); } @@ -1821,13 +2159,13 @@ void test_update() /******************************************************** * to test simple prepare * *********************************************************/ -void test_init_prepare() +static void test_prepare_noparam() { MYSQL_STMT *stmt; - int param_count, rc; + int rc; MYSQL_RES *result; - myheader("test_init_prepare"); + myheader("test_prepare_noparam"); rc = mysql_query(mysql,"DROP TABLE IF EXISTS my_prepare"); myquery(rc); @@ -1842,11 +2180,9 @@ void test_init_prepare() /* insert by prepare */ strcpy(query,"INSERT INTO my_prepare VALUES(10,'venu')"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout," total parameters in insert:%d\n", param_count); - assert(param_count == 0); + verify_param_count(stmt,0); rc = mysql_execute(stmt); mystmt(stmt, rc); @@ -1865,7 +2201,7 @@ void test_init_prepare() result = mysql_store_result(mysql); mytest(result); - assert(1 == my_process_result_set(result)); + myassert(1 == my_process_result_set(result)); mysql_free_result(result); } @@ -1873,12 +2209,12 @@ void test_init_prepare() /******************************************************** * to test simple bind result * *********************************************************/ -void test_bind_result() +static void test_bind_result() { MYSQL_STMT *stmt; int rc; const char query[100]; - int nData; + int nData, length, length1; char szData[100]; MYSQL_BIND bind[2]; @@ -1903,6 +2239,9 @@ void test_bind_result() rc = mysql_query(mysql,"INSERT INTO test_bind_result VALUES(20,'MySQL')"); myquery(rc); + rc = mysql_query(mysql,"INSERT INTO test_bind_result(col2) VALUES('monty')"); + myquery(rc); + rc = mysql_commit(mysql); myquery(rc); @@ -1910,13 +2249,15 @@ void test_bind_result() bind[0].buffer_type=FIELD_TYPE_LONG; bind[0].buffer= (gptr) &nData; /* integer data */ + bind[0].length= (long *)&length; bind[1].buffer_type=FIELD_TYPE_STRING; bind[1].buffer=szData; /* string data */ bind[1].buffer_length=sizeof(szData); + bind[1].length=(long *)&length1; strcpy((char *)query , "SELECT * FROM test_bind_result"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); rc = mysql_bind_result(stmt,bind); mystmt(stmt, rc); @@ -1927,30 +2268,397 @@ void test_bind_result() rc = mysql_fetch(stmt); mystmt(stmt,rc); - printf("\n row 1:%d,%s",nData, szData); - assert(nData == 10); - assert(strcmp(szData,"venu")==0); + fprintf(stdout,"\n row 1: %d,%s(%d)",nData, szData, length1); + myassert(nData == 10); + myassert(strcmp(szData,"venu")==0); + myassert(length1 == 4); rc = mysql_fetch(stmt); mystmt(stmt,rc); - printf("\n row 2:%d,%s",nData, szData); - assert(nData == 20); - assert(strcmp(szData,"MySQL")==0); + fprintf(stdout,"\n row 2: %d,%s(%d)",nData, szData, length1); + myassert(nData == 20); + myassert(strcmp(szData,"MySQL")==0); + myassert(length1 == 5); + + length=99; + rc = mysql_fetch(stmt); + mystmt(stmt,rc); + + if (length == MYSQL_NULL_DATA) + fprintf(stdout,"\n row 3: NULL,%s(%d)", szData, length1); + else + fprintf(stdout,"\n row 3: %d,%s(%d)", nData, szData, length1); + myassert(length == MYSQL_NULL_DATA); + myassert(strcmp(szData,"monty")==0); + myassert(length1 == 5); rc = mysql_fetch(stmt); - assert(rc == MYSQL_NO_DATA); + myassert(rc == MYSQL_NO_DATA); + + mysql_stmt_close(stmt); +} + + +/******************************************************** +* to test ext bind result * +*********************************************************/ +static void test_bind_result_ext() +{ + MYSQL_STMT *stmt; + int rc; + const char query[100]; + uchar t_data; + short s_data; + int i_data; + longlong b_data; + float f_data; + double d_data; + char szData[20], bData[20]; + int szLength, bLength; + MYSQL_BIND bind[8]; + + myheader("test_bind_result_ext"); + + init_bind(bind); + rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_bind_result"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + rc = mysql_query(mysql,"CREATE TABLE test_bind_result(c1 tinyint, c2 smallint, \ + c3 int, c4 bigint, \ + c5 float, c6 double, \ + c7 varbinary(10), \ + c8 varchar(50))"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + rc = mysql_query(mysql,"INSERT INTO test_bind_result VALUES(19,2999,3999,4999999,\ + 2345.6,5678.89563,\ + 'venu','mysql')"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + bind[0].buffer_type=MYSQL_TYPE_TINY; + bind[0].buffer=(gptr)&t_data; + + bind[1].buffer_type=MYSQL_TYPE_SHORT; + bind[2].buffer_type=MYSQL_TYPE_LONG; + + bind[3].buffer_type=MYSQL_TYPE_LONGLONG; + bind[1].buffer=(gptr)&s_data; + + bind[2].buffer=(gptr)&i_data; + bind[3].buffer=(gptr)&b_data; + + bind[4].buffer_type=MYSQL_TYPE_FLOAT; + bind[4].buffer=(gptr)&f_data; + + bind[5].buffer_type=MYSQL_TYPE_DOUBLE; + bind[5].buffer=(gptr)&d_data; + + bind[6].buffer_type=MYSQL_TYPE_STRING; + bind[6].buffer=(gptr)&szData; + bind[6].length=(long *)&szLength; + + bind[7].buffer_type=MYSQL_TYPE_TINY_BLOB; + bind[7].buffer=(gptr)&bData; + bind[7].length=(long *)&bLength; + + strcpy((char *)query , "SELECT * FROM test_bind_result"); + stmt = mysql_prepare(mysql, query, strlen(query)); + mystmt_init(stmt); + + rc = mysql_bind_result(stmt,bind); + mystmt(stmt, rc); + + rc = mysql_execute(stmt); + mystmt(stmt, rc); + + rc = mysql_fetch(stmt); + mystmt(stmt,rc); + + fprintf(stdout, "\n data (tiny) : %d", t_data); + fprintf(stdout, "\n data (short) : %d", s_data); + fprintf(stdout, "\n data (int) : %d", i_data); + fprintf(stdout, "\n data (big) : %lld", b_data); + + fprintf(stdout, "\n data (float) : %f", f_data); + fprintf(stdout, "\n data (double) : %f", d_data); + + fprintf(stdout, "\n data (str) : %s(%d)", szData, szLength); + fprintf(stdout, "\n data (bin) : %s(%d)", bData, bLength); + + + myassert(t_data == 19); + myassert(s_data == 2999); + myassert(i_data == 3999); + myassert(b_data == 4999999); + /*myassert(f_data == 2345.60);*/ + /*myassert(d_data == 5678.89563);*/ + myassert(strcmp(szData,"venu")==0); + myassert(strcmp(bData,"mysql")==0); + myassert(szLength == 4); + myassert(bLength == 5); + + rc = mysql_fetch(stmt); + myassert(rc == MYSQL_NO_DATA); + + mysql_stmt_close(stmt); +} + + +/******************************************************** +* to test ext bind result * +*********************************************************/ +static void test_bind_result_ext1() +{ + MYSQL_STMT *stmt; + int rc; + const char query[100]; + char t_data[20]; + float s_data; + short i_data; + short b_data; + int f_data; + long bData; + long length[11]; + char d_data[20]; + double szData; + MYSQL_BIND bind[8]; + + myheader("test_bind_result_ext1"); + + init_bind(bind); + rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_bind_result"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + rc = mysql_query(mysql,"CREATE TABLE test_bind_result(c1 tinyint, c2 smallint, \ + c3 int, c4 bigint, \ + c5 float, c6 double, \ + c7 varbinary(10), \ + c8 varchar(10))"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + rc = mysql_query(mysql,"INSERT INTO test_bind_result VALUES(120,2999,3999,54,\ + 2.6,58.89,\ + '206','6.7')"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + bind[0].buffer_type=MYSQL_TYPE_STRING; + bind[0].buffer=(gptr)t_data; + + for (rc=0; rc <= 7; rc++) + bind[rc].length= &length[rc]; + + bind[1].buffer_type=MYSQL_TYPE_FLOAT; + bind[1].buffer=(gptr)&s_data; + + bind[2].buffer_type=MYSQL_TYPE_SHORT; + bind[2].buffer=(gptr)&i_data; + + bind[3].buffer_type=MYSQL_TYPE_TINY; + bind[3].buffer=(gptr)&b_data; + + bind[4].buffer_type=MYSQL_TYPE_LONG; + bind[4].buffer=(gptr)&f_data; + + bind[5].buffer_type=MYSQL_TYPE_STRING; + bind[5].buffer=(gptr)d_data; + + bind[6].buffer_type=MYSQL_TYPE_LONG; + bind[6].buffer=(gptr)&bData; + + bind[7].buffer_type=MYSQL_TYPE_DOUBLE; + bind[7].buffer=(gptr)&szData; + + strcpy((char *)query , "SELECT * FROM test_bind_result"); + stmt = mysql_prepare(mysql, query, strlen(query)); + mystmt_init(stmt); + + rc = mysql_bind_result(stmt,bind); + mystmt(stmt, rc); + + rc = mysql_execute(stmt); + mystmt(stmt, rc); + + rc = mysql_fetch(stmt); + mystmt(stmt,rc); + + fprintf(stdout, "\n data (tiny) : %s(%ld)", t_data, length[0]); + fprintf(stdout, "\n data (short) : %f(%ld)", s_data, length[1]); + fprintf(stdout, "\n data (int) : %d(%ld)", i_data, length[2]); + fprintf(stdout, "\n data (big) : %d(%ld)", b_data, length[3]); + + fprintf(stdout, "\n data (float) : %d(%ld)", f_data, length[4]); + fprintf(stdout, "\n data (double) : %s(%ld)", d_data, length[5]); + + fprintf(stdout, "\n data (bin) : %ld(%ld)", bData, length[6]); + fprintf(stdout, "\n data (str) : %g(%ld)", szData, length[7]); + + myassert(strcmp(t_data,"120")==0); + myassert(i_data == 3999); + myassert(f_data == 2); + myassert(strcmp(d_data,"58.89")==0); + + myassert(length[0] == 3); + myassert(length[1] == 4); + myassert(length[2] == 2); + myassert(length[3] == 1); + myassert(length[4] == 4); + myassert(length[5] == 5); + myassert(length[6] == 4); + myassert(length[7] == 8); + + rc = mysql_fetch(stmt); + myassert(rc == MYSQL_NO_DATA); mysql_stmt_close(stmt); } /******************************************************** -* to test simple prepare with all possible types * +* to test fetching of date, time and ts * *********************************************************/ -void test_prepare_ext() +static void test_fetch_date() { MYSQL_STMT *stmt; - int rc,param_count; + int rc, year; + char date[25], time[25], ts[25], ts_4[15], ts_6[20], dt[20]; + int d_length, t_length, ts_length, ts4_length, ts6_length, + dt_length, y_length; + + MYSQL_BIND bind[3]; + + myheader("test_fetch_date"); + + init_bind(bind); + rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_bind_result"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + rc = mysql_query(mysql,"CREATE TABLE test_bind_result(c1 date, c2 time, \ + c3 timestamp(14), \ + c4 year, \ + c5 datetime, \ + c6 timestamp(4), \ + c7 timestamp(6))"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + rc = mysql_query(mysql,"INSERT INTO test_bind_result VALUES('2002-01-02',\ + '12:49:00',\ + '2002-01-02 17:46:59', \ + 2010,\ + '2010-07-10', \ + '2020','1999-12-29')"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + bind[0].buffer_type=MYSQL_TYPE_STRING; + bind[1]=bind[2]=bind[0]; + + bind[0].buffer=(gptr)&date; + bind[0].length=(long *)&d_length; + + bind[1].buffer=(gptr)&time; + bind[1].length=(long *)&t_length; + + bind[2].buffer=(gptr)&ts; + bind[2].length=(long *)&ts_length; + + bind[3].buffer_type=MYSQL_TYPE_LONG; + bind[3].buffer=(gptr)&year; + bind[3].length=(long *)&y_length; + + bind[4].buffer_type=MYSQL_TYPE_STRING; + bind[4].buffer=(gptr)&dt; + bind[4].length=(long *)&dt_length; + + bind[5].buffer_type=MYSQL_TYPE_STRING; + bind[5].buffer=(gptr)&ts_4; + bind[5].length=(long *)&ts4_length; + + bind[6].buffer_type=MYSQL_TYPE_STRING; + bind[6].buffer=(gptr)&ts_6; + bind[6].length=(long *)&ts6_length; + + stmt = mysql_prepare(mysql, "SELECT * FROM test_bind_result", 50); + mystmt_init(stmt); + + rc = mysql_bind_result(stmt,bind); + mystmt(stmt, rc); + + rc = mysql_execute(stmt); + mystmt(stmt, rc); + + ts_4[0]='\0'; + rc = mysql_fetch(stmt); + mystmt(stmt,rc); + + fprintf(stdout, "\n date : %s(%d)", date, d_length); + fprintf(stdout, "\n time : %s(%d)", time, t_length); + fprintf(stdout, "\n ts : %s(%d)", ts, ts_length); + fprintf(stdout, "\n year : %d(%d)", year, y_length); + fprintf(stdout, "\n dt : %s(%d)", dt, dt_length); + fprintf(stdout, "\n ts(4) : %s(%d)", ts_4, ts4_length); + fprintf(stdout, "\n ts(6) : %s(%d)", ts_6, ts6_length); + + myassert(strcmp(date,"2002-01-02")==0); + myassert(d_length == 10); + + myassert(strcmp(time,"12:49:00")==0); + myassert(d_length == 8); + + myassert(strcmp(ts,"2002-01-02 17:46:59")==0); + myassert(ts_length == 19); + + myassert(year == 2010); + myassert(y_length == 4); + + myassert(strcmp(dt,"2010-07-10")==0); + myassert(dt_length == 10); + + myassert(ts_4[0] == '\0'); + myassert(ts4_length == 0); + + myassert(strcmp(ts_6,"1999-12-29")==0); + myassert(ts6_length == 10); + + rc = mysql_fetch(stmt); + myassert(rc == MYSQL_NO_DATA); + + mysql_stmt_close(stmt); +} + + +/******************************************************** +* to test simple prepare with all possible types * +*********************************************************/ +static void test_prepare_ext() +{ + MYSQL_STMT *stmt; + int rc; char *sql; int nData=1; MYSQL_RES *result; @@ -2012,9 +2720,7 @@ void test_prepare_ext() stmt = mysql_prepare(mysql,query, strlen(query)); myquery(rc); - param_count = mysql_param_count(stmt); - fprintf(stdout," total parameters in insert:%d\n", param_count); - assert(param_count == 6); + verify_param_count(stmt,6); /*tinyint*/ bind_int[0].buffer_type=FIELD_TYPE_TINY; @@ -2065,7 +2771,7 @@ void test_prepare_ext() result = mysql_store_result(mysql); mytest(result); - assert(nData == my_process_result_set(result)); + myassert(nData == my_process_result_set(result)); mysql_free_result(result); } @@ -2075,14 +2781,14 @@ void test_prepare_ext() /******************************************************** * to test real and alias names * *********************************************************/ -void test_field_names() +static void test_field_names() { int rc; MYSQL_RES *result; myheader("test_field_names"); - printf("\n%d,%d,%d",MYSQL_TYPE_DECIMAL,MYSQL_TYPE_NEWDATE,MYSQL_TYPE_ENUM); + fprintf(stdout,"\n %d,%d,%d",MYSQL_TYPE_DECIMAL,MYSQL_TYPE_NEWDATE,MYSQL_TYPE_ENUM); rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_field_names1"); myquery(rc); @@ -2108,7 +2814,7 @@ void test_field_names() result = mysql_use_result(mysql); mytest(result); - assert(0 == my_process_result_set(result)); + myassert(0 == my_process_result_set(result)); mysql_free_result(result); /* with table name included with true column name */ @@ -2118,23 +2824,20 @@ void test_field_names() result = mysql_use_result(mysql); mytest(result); - assert(0 == my_process_result_set(result)); + myassert(0 == my_process_result_set(result)); mysql_free_result(result); } /******************************************************** * to test warnings * *********************************************************/ -void test_warnings() +static void test_warnings() { int rc; MYSQL_RES *result; myheader("test_warnings"); - rc = mysql_query(mysql,"USE test"); - myquery(rc); - rc = mysql_query(mysql,"SHOW WARNINGS"); myquery(rc); @@ -2148,7 +2851,7 @@ void test_warnings() /******************************************************** * to test errors * *********************************************************/ -void test_errors() +static void test_errors() { int rc; MYSQL_RES *result; @@ -2170,10 +2873,10 @@ void test_errors() /******************************************************** * to test simple prepare-insert * *********************************************************/ -void test_insert() +static void test_insert() { MYSQL_STMT *stmt; - int rc,param_count, length; + int rc, length; char query[200]; char str_data[50]; char tiny_data; @@ -2199,11 +2902,9 @@ void test_insert() bzero(bind, sizeof(bind)); strcpy(query,"INSERT INTO test_prep_insert VALUES(?,?)"); stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout," total parameters in insert:%d\n", param_count); - assert(param_count == 2); + verify_param_count(stmt,2); /* tinyint */ bind[0].buffer_type=FIELD_TYPE_TINY; @@ -2238,7 +2939,7 @@ void test_insert() result = mysql_store_result(mysql); mytest(result); - assert((int)tiny_data == my_process_result_set(result)); + myassert((int)tiny_data == my_process_result_set(result)); mysql_free_result(result); } @@ -2246,10 +2947,10 @@ void test_insert() /******************************************************** * to test simple prepare-resultset info * *********************************************************/ -void test_prepare_resultset() +static void test_prepare_resultset() { MYSQL_STMT *stmt; - int rc,param_count; + int rc; char query[200]; MYSQL_RES *result; @@ -2268,38 +2969,15 @@ void test_prepare_resultset() name varchar(50),extra double)"); myquery(rc); - /* insert by prepare */ - strcpy(query,"INSERT INTO test_prepare_resultset(id,name) VALUES(?,?)"); - stmt = mysql_prepare(mysql, query, strlen(query)); - myxquery(stmt); + strcpy(query,"SELECT * FROM test_prepare_resultset"); + stmt = PREPARE(mysql, query); + mystmt_init(stmt); - param_count = mysql_param_count(stmt); - fprintf(stdout," total parameters in insert:%d\n", param_count); - assert(param_count == 2); + verify_param_count(stmt,0); - rc = mysql_query(mysql,"SELECT * FROM test_prepare_resultset"); - myquery(rc); - - /* get the prepared-result */ result = mysql_prepare_result(stmt); - assert( result != 0); - - my_print_result_metadata(result); - mysql_free_result(result); - - result = mysql_store_result(mysql); mytest(result); - - assert(0 == my_process_result_set(result)); - mysql_free_result(result); - - /* get the prepared-result */ - result = mysql_prepare_result(stmt); - assert( result != 0); - my_print_result_metadata(result); - mysql_free_result(result); - mysql_stmt_close(stmt); } @@ -2307,7 +2985,7 @@ void test_prepare_resultset() * to test field flags (verify .NET provider) * *********************************************************/ -void test_field_flags() +static void test_field_flags() { int rc; MYSQL_RES *result; @@ -2348,22 +3026,459 @@ void test_field_flags() for(i=0; i< mysql_num_fields(result); i++) { field = mysql_fetch_field(result); - printf("\nfield:%d",i); + fprintf(stdout,"\n field:%d",i); if(field->flags & NOT_NULL_FLAG) - printf("\n NOT_NULL_FLAG"); + fprintf(stdout,"\n NOT_NULL_FLAG"); if(field->flags & PRI_KEY_FLAG) - printf("\n PRI_KEY_FLAG"); + fprintf(stdout,"\n PRI_KEY_FLAG"); if(field->flags & UNIQUE_KEY_FLAG) - printf("\n UNIQUE_KEY_FLAG"); + fprintf(stdout,"\n UNIQUE_KEY_FLAG"); if(field->flags & MULTIPLE_KEY_FLAG) - printf("\n MULTIPLE_KEY_FLAG"); + fprintf(stdout,"\n MULTIPLE_KEY_FLAG"); if(field->flags & AUTO_INCREMENT_FLAG) - printf("\n AUTO_INCREMENT_FLAG"); + fprintf(stdout,"\n AUTO_INCREMENT_FLAG"); } mysql_free_result(result); } +/************************************************************** + * Test mysql_stmt_close for open stmts * +**************************************************************/ +static void test_stmt_close() +{ + MYSQL *lmysql; + MYSQL_STMT *stmt1, *stmt2, *stmt3, *stmt_x; + MYSQL_BIND param[1]; + MYSQL_RES *result; + char query[100]; + unsigned int count; + int rc; + + myheader("test_stmt_close"); + + init_bind(param); + if(!(lmysql = mysql_init(NULL))) + { + myerror("mysql_init() failed"); + exit(0); + } + if (!(mysql_real_connect(lmysql,opt_host,opt_user, + opt_password, opt_db ? opt_db:"inter_client_test_db", opt_port, + opt_unix_socket, 0))) + { + myerror("connection failed"); + exit(0); + } + if (opt_db) + strcpy(current_db,opt_db); + + /* set AUTOCOMMIT to ON*/ + mysql_autocommit(lmysql, true); + mysql_query(lmysql,"DROP TABLE IF EXISTS test_stmt_close"); + mysql_query(lmysql,"CREATE TABLE test_stmt_close(id int)"); + + strcpy(query,"ALTER TABLE test_stmt_close ADD name varchar(20)"); + stmt1= PREPARE(lmysql, query); + mystmt_init(stmt1); + count= mysql_param_count(stmt1); + fprintf(stdout,"\n total params in alter: %d", count); + myassert(count == 0); + strcpy(query,"INSERT INTO test_stmt_close(id) VALUES(?)"); + stmt_x= PREPARE(mysql, query); + mystmt_init(stmt_x); + count= mysql_param_count(stmt_x); + fprintf(stdout,"\n total params in insert: %d", count); + myassert(count == 1); + strcpy(query,"UPDATE test_stmt_close SET id=? WHERE id=?"); + stmt3= PREPARE(lmysql, query); + mystmt_init(stmt3); + count= mysql_param_count(stmt3); + fprintf(stdout,"\n total params in update: %d", count); + myassert(count == 2); + strcpy(query,"SELECT * FROM test_stmt_close WHERE id=?"); + stmt2= PREPARE(lmysql, query); + mystmt_init(stmt2); + count= mysql_param_count(stmt2); + fprintf(stdout,"\n total params in select: %d", count); + myassert(count == 1); + + rc= mysql_stmt_close(stmt1); + fprintf(stdout,"\n mysql_close_stmt(1) returned: %d", rc); + myassert(rc == 0); + mysql_close(lmysql); /* it should free all stmts */ +#if NOT_VALID + rc= mysql_stmt_close(stmt3); + fprintf(stdout,"\n mysql_close_stmt(3) returned: %d", rc); + myassert( rc == 1); + rc= mysql_stmt_close(stmt2); + fprintf(stdout,"\n mysql_close_stmt(2) returned: %d", rc); + myassert( rc == 1); +#endif + + count= 100; + param[0].buffer=(gptr)&count; + param[0].buffer_type=MYSQL_TYPE_LONG; + rc = mysql_bind_param(stmt_x, param); + mystmt(stmt_x, rc); + rc = mysql_execute(stmt_x); + mystmt(stmt_x, rc); + + rc= (ulong)mysql_affected_rows(stmt_x->mysql); + fprintf(stdout,"\n total rows affected: %d", rc); + myassert (rc == 1); + + rc= mysql_stmt_close(stmt_x); + fprintf(stdout,"\n mysql_close_stmt(x) returned: %d", rc); + myassert( rc == 0); + + /*verify_col_data("test_stmt_close", "id", "100");*/ + rc = mysql_query(mysql,"SELECT id FROM test_stmt_close"); + myquery(rc); + + result = mysql_store_result(mysql); + mytest(result); + + myassert(1 == my_process_result_set(result)); + mysql_free_result(result); +} + +/******************************************************** + * To test simple set-variable prepare * +*********************************************************/ +static void test_set_variable() +{ + MYSQL_STMT *stmt; + int rc, select_limit=88; + char query[200]; + MYSQL_BIND bind[1]; + MYSQL_RES *result; + + + myheader("test_set_variable"); + + rc = mysql_autocommit(mysql, true); + myquery(rc); + + strcpy(query,"SET GLOBAL delayed_insert_limit=?"); + stmt = mysql_prepare(mysql, query, strlen(query)); + mystmt_init(stmt); + + verify_param_count(stmt,1); + + result= mysql_param_result(stmt); + mytest_r(result); + + init_bind(bind); + + bind[0].buffer_type= MYSQL_TYPE_LONG; + bind[0].buffer=(gptr)&select_limit; + + rc = mysql_bind_param(stmt, bind); + mystmt(stmt,rc); + + rc= mysql_execute(stmt); + mystmt(stmt,rc); + + mysql_store_result(mysql); + + strcpy(query,"show variables like 'delayed_insert_limit'"); + rc = mysql_query(mysql,query); + myquery(rc); + + verify_col_data(NullS, NullS, "88"); + +#if TO_BE_FIXED + + select_limit= 100;/* reset to default */ + rc= mysql_execute(stmt); + mystmt(stmt,rc); + + mysql_store_result(mysql); + mysql_stmt_close(stmt); + + rc = mysql_query(mysql,query); + myquery(rc); + + verify_col_data(NullS, NullS, "100"); +#endif + mysql_stmt_close(stmt); +} +#if NOT_USED +/* Insert meta info .. */ +static void test_insert_meta() +{ + MYSQL_STMT *stmt; + int rc; + char query[200]; + MYSQL_RES *result; + MYSQL_FIELD *field; + + myheader("test_insert_meta"); + + rc = mysql_autocommit(mysql, true); + myquery(rc); + + rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_prep_insert"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + rc = mysql_query(mysql,"CREATE TABLE test_prep_insert(col1 tinyint,\ + col2 varchar(50), col3 varchar(30))"); + myquery(rc); + + strcpy(query,"INSERT INTO test_prep_insert VALUES(10,'venu1','test')"); + stmt = mysql_prepare(mysql, query, strlen(query)); + mystmt_init(stmt); + + verify_param_count(stmt,0); + + result= mysql_param_result(stmt); + mytest_r(result); + + strcpy(query,"INSERT INTO test_prep_insert VALUES(?,'venu',?)"); + stmt = mysql_prepare(mysql, query, strlen(query)); + mystmt_init(stmt); + + verify_param_count(stmt,2); + + result= mysql_param_result(stmt); + mytest(result); + + my_print_result_metadata(result); + + mysql_field_seek(result, 0); + field= mysql_fetch_field(result); + mytest(field); + fprintf(stdout, "\n obtained: `%s` (expected: `%s`)", field->name, "col1"); + myassert(strcmp(field->name,"col1")==0); + + field= mysql_fetch_field(result); + mytest(field); + fprintf(stdout, "\n obtained: `%s` (expected: `%s`)", field->name, "col3"); + myassert(strcmp(field->name,"col3")==0); + + field= mysql_fetch_field(result); + mytest_r(field); + + mysql_free_result(result); + mysql_stmt_close(stmt); +} + +/* Update meta info .. */ +static void test_update_meta() +{ + MYSQL_STMT *stmt; + int rc; + char query[200]; + MYSQL_RES *result; + MYSQL_FIELD *field; + + myheader("test_update_meta"); + + rc = mysql_autocommit(mysql, true); + myquery(rc); + + rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_prep_update"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + rc = mysql_query(mysql,"CREATE TABLE test_prep_update(col1 tinyint,\ + col2 varchar(50), col3 varchar(30))"); + myquery(rc); + + strcpy(query,"UPDATE test_prep_update SET col1=10, col2='venu1' WHERE col3='test'"); + stmt = mysql_prepare(mysql, query, strlen(query)); + mystmt_init(stmt); + + verify_param_count(stmt,0); + + result= mysql_param_result(stmt); + mytest_r(result); + + strcpy(query,"UPDATE test_prep_update SET col1=?, col2='venu' WHERE col3=?"); + stmt = mysql_prepare(mysql, query, strlen(query)); + mystmt_init(stmt); + + verify_param_count(stmt,2); + + result= mysql_param_result(stmt); + mytest(result); + + my_print_result_metadata(result); + + mysql_field_seek(result, 0); + field= mysql_fetch_field(result); + mytest(field); + fprintf(stdout, "\n col obtained: `%s` (expected: `%s`)", field->name, "col1"); + fprintf(stdout, "\n tab obtained: `%s` (expected: `%s`)", field->table, "test_prep_update"); + myassert(strcmp(field->name,"col1")==0); + myassert(strcmp(field->table,"test_prep_update")==0); + + field= mysql_fetch_field(result); + mytest(field); + fprintf(stdout, "\n col obtained: `%s` (expected: `%s`)", field->name, "col3"); + fprintf(stdout, "\n tab obtained: `%s` (expected: `%s`)", field->table, "test_prep_update"); + myassert(strcmp(field->name,"col3")==0); + myassert(strcmp(field->table,"test_prep_update")==0); + + field= mysql_fetch_field(result); + mytest_r(field); + + mysql_free_result(result); + mysql_stmt_close(stmt); +} + +/* Select meta info .. */ +static void test_select_meta() +{ + MYSQL_STMT *stmt; + int rc; + char query[200]; + MYSQL_RES *result; + MYSQL_FIELD *field; + + myheader("test_select_meta"); + + rc = mysql_autocommit(mysql, true); + myquery(rc); + + rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_prep_select"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + rc = mysql_query(mysql,"CREATE TABLE test_prep_select(col1 tinyint,\ + col2 varchar(50), col3 varchar(30))"); + myquery(rc); + + strcpy(query,"SELECT * FROM test_prep_select WHERE col1=10"); + stmt = mysql_prepare(mysql, query, strlen(query)); + mystmt_init(stmt); + + verify_param_count(stmt,0); + + result= mysql_param_result(stmt); + mytest_r(result); + + strcpy(query,"SELECT col1, col3 from test_prep_select WHERE col1=? AND col3='test' AND col2= ?"); + stmt = mysql_prepare(mysql, query, strlen(query)); + mystmt_init(stmt); + + verify_param_count(stmt,2); + + result= mysql_param_result(stmt); + mytest(result); + + my_print_result_metadata(result); + + mysql_field_seek(result, 0); + field= mysql_fetch_field(result); + mytest(field); + fprintf(stdout, "\n col obtained: `%s` (expected: `%s`)", field->name, "col1"); + fprintf(stdout, "\n tab obtained: `%s` (expected: `%s`)", field->table, "test_prep_select"); + myassert(strcmp(field->name,"col1")==0); + myassert(strcmp(field->table,"test_prep_select")==0); + + field= mysql_fetch_field(result); + mytest(field); + fprintf(stdout, "\n col obtained: `%s` (expected: `%s`)", field->name, "col2"); + fprintf(stdout, "\n tab obtained: `%s` (expected: `%s`)", field->table, "test_prep_select"); + myassert(strcmp(field->name,"col2")==0); + myassert(strcmp(field->table,"test_prep_select")==0); + + field= mysql_fetch_field(result); + mytest_r(field); + + mysql_free_result(result); + mysql_stmt_close(stmt); +} +#endif + +/* Test FUNCTION field info / DATE_FORMAT() table_name . */ +static void test_func_fields() +{ + int rc; + MYSQL_RES *result; + MYSQL_FIELD *field; + + myheader("test_func_fields"); + + rc = mysql_autocommit(mysql, true); + myquery(rc); + + rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_dateformat"); + myquery(rc); + + rc = mysql_commit(mysql); + myquery(rc); + + rc = mysql_query(mysql,"CREATE TABLE test_dateformat(id int, \ + ts timestamp)"); + myquery(rc); + + rc = mysql_query(mysql, "INSERT INTO test_dateformat(id) values(10)"); + myquery(rc); + + rc = mysql_query(mysql, "SELECT ts FROM test_dateformat"); + myquery(rc); + + result = mysql_store_result(mysql); + mytest(result); + + field = mysql_fetch_field(result); + mytest(field); + fprintf(stdout,"\n table name: `%s` (expected: `%s`)", field->table, + "test_dateformat"); + myassert(strcmp(field->table, "test_dateformat")==0); + + field = mysql_fetch_field(result); + mytest_r(field); /* no more fields */ + + mysql_free_result(result); + + /* DATE_FORMAT */ + rc = mysql_query(mysql, "SELECT DATE_FORMAT(ts,'%Y') AS 'venu' FROM test_dateformat"); + myquery(rc); + + result = mysql_store_result(mysql); + mytest(result); + + field = mysql_fetch_field(result); + mytest(field); + fprintf(stdout,"\n table name: `%s` (expected: `%s`)", field->table, ""); + myassert(field->table[0] == '\0'); + + field = mysql_fetch_field(result); + mytest_r(field); /* no more fields */ + + mysql_free_result(result); + + /* FIELD ALIAS TEST */ + rc = mysql_query(mysql, "SELECT DATE_FORMAT(ts,'%Y') AS 'YEAR' FROM test_dateformat"); + myquery(rc); + + result = mysql_store_result(mysql); + mytest(result); + + field = mysql_fetch_field(result); + mytest(field); + fprintf(stdout,"\n field name: `%s` (expected: `%s`)", field->name, "YEAR"); + fprintf(stdout,"\n field org name: `%s` (expected: `%s`)",field->org_name,""); + myassert(strcmp(field->name, "YEAR")==0); + myassert(field->org_name[0] == '\0'); + + field = mysql_fetch_field(result); + mytest_r(field); /* no more fields */ + + mysql_free_result(result); +} + static struct my_option myctest_long_options[] = { {"help", '?', "Display this help and exit", 0, 0, 0, GET_NO_ARG, NO_ARG, 0, @@ -2398,24 +3513,24 @@ static void usage(void) puts("and you are welcome to modify and redistribute it under the GPL license\n"); puts(" Copyright (C) 1995-2002 MySQL AB "); puts("-----------------------------------------------------------------------\n"); - printf("usage: %s [OPTIONS]\n\n", my_progname); - printf("\ + fprintf(stdout,"usage: %s [OPTIONS]\n\n", my_progname); + fprintf(stdout,"\ -?, --help Display this help message and exit.\n\ -D --database=... Database name to be used for test.\n\ -h, --host=... Connect to host.\n\ -p, --password[=...] Password to use when connecting to server.\n"); #ifdef __WIN__ - printf("\ + fprintf(stdout,"\ -W, --pipe Use named pipes to connect to server.\n"); #endif - printf("\ + fprintf(stdout,"\ -P, --port=... Port number to use for connection.\n\ -S, --socket=... Socket file to use for connection.\n"); #ifndef DONT_ALLOW_USER_CHANGE - printf("\ + fprintf(stdout,"\ -u, --user=# User for login if not current user.\n"); #endif - printf("*********************************************************************\n"); + fprintf(stdout,"*********************************************************************\n"); } static my_bool @@ -2471,24 +3586,52 @@ int main(int argc, char **argv) MY_INIT(argv[0]); get_options(argc,argv); - client_connect(); /* connect to server */ - + client_connect(); /* connect to server */ + test_select_prepare(); + test_prepare(); + test_prepare_simple(); + test_bind_result(); /* result bind test */ + test_fetch_null(); /* to fetch null data */ + test_fetch_date(); + test_bind_result_ext(); /* result bind test - extension */ + test_bind_result_ext1(); /* result bind test - extension */ + test_select_direct(); /* direct select - protocol_simple debug */ + test_select_prepare(); /* prepare select - protocol_prep debug */ + test_select_direct(); /* direct select - protocol_simple debug */ + test_select(); + test_select_version(); + test_set_variable(); /* set variable prepare */ +#if NOT_USED + test_select_meta(); /* select param meta information */ + test_update_meta(); /* update param meta information */ + test_insert_meta(); /* insert param meta information */ +#endif + test_simple_update(); /* simple update test */ + test_func_fields(); + test_long_data(); + test_insert(); + test_set_variable(); + test_tran_innodb(); + test_select_version(); + test_select_simple(); + test_debug_example(); + test_select(); + test_select_show(); test_null(); /* test null data handling */ - test_simple_update(); - //test_select_simple(); - //test_prepare_resultset(); - //test_select(); /* simple prepare-select */ + test_simple_update(); + test_prepare_resultset(); + test_prepare_noparam();/* prepare without parameters */ + test_select(); /* simple prepare-select */ test_insert(); /* prepare with insert */ - //test_bind_result(); /* result bind test */ - //test_long_data(); /* long data handling in pieces */ + test_bind_result(); /* result bind test */ + test_long_data(); /* long data handling in pieces */ test_prepare_simple();/* simple prepare */ test_prepare(); /* prepare test */ - test_prepare_simple();/* simple prepare */ test_null(); /* test null data handling */ test_debug_example(); /* some debugging case */ test_update(); /* prepare-update test */ test_simple_update(); /* simple prepare with update */ - //test_long_data(); /* long data handling in pieces */ + test_long_data(); /* long data handling in pieces */ test_simple_delete(); /* prepare with delete */ test_field_names(); /* test for field names */ test_double_compare();/* float comparision */ @@ -2499,20 +3642,23 @@ int main(int argc, char **argv) test_tran_innodb(); /* transaction test on InnoDB table type */ test_prepare_ext(); /* test prepare with all types conversion -- TODO */ test_prepare_syntax();/* syntax check for prepares */ - //test_prepare_field_result(); /* prepare meta info */ + test_prepare_field_result(); /* prepare meta info */ + test_prepare_resultset(); test_field_names(); /* test for field names */ test_field_flags(); /* test to help .NET provider team */ - //test_long_data_str(); /* long data handling */ - //test_long_data_str1();/* yet another long data handling */ - //test_long_data_bin(); /* long binary insertion */ + test_long_data_str(); /* long data handling */ + test_long_data_str1();/* yet another long data handling */ + test_long_data_bin(); /* long binary insertion */ test_warnings(); /* show warnings test */ test_errors(); /* show errors test */ - //test_select_simple(); /* simple select prepare */ - //test_prepare_resultset();/* prepare meta info test */ - + test_select_simple(); /* simple select prepare */ + test_prepare_resultset();/* prepare meta info test */ + test_func_fields(); /* FUNCTION field info */ + /*test_stmt_close(); */ /* mysql_stmt_close() test -- hangs */ + test_prepare_field_result(); /* prepare meta info */ client_disconnect(); /* disconnect from server */ - - fprintf(stdout,"\ndone !!!\n"); + + fprintf(stdout,"\n\nSUCCESS !!!\n"); return(0); }