Skip to content

M
mariadb
Commit df2678db authored by venu@myvenu.com's avatar venu@myvenu.com
Browse files
Options

Prepared statements + binary protocol test update

parent fc7a1bfa
Hide whitespace changes
Inline Side-by-side
Showing with 1638 additions and 492 deletions
tests/client_test.c
View file @ df2678db
...@@ -32,14 +32,13 @@ ...@@ -32,14 +32,13 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <assert.h>
/* mysql client headers */ /* mysql client headers */
#include <my_sys.h> #include <my_sys.h>
#include <mysql.h> #include <mysql.h>
#include <my_getopt.h> #include <my_getopt.h>
#include <assert.h>
#ifndef true #ifndef true
#define true 1 #define true 1
#endif #endif
...@@ -58,100 +57,119 @@ static char *opt_user=0; ...@@ -58,100 +57,119 @@ static char *opt_user=0;
static char *opt_password=0; static char *opt_password=0;
static char *opt_host=0; static char *opt_host=0;
static char *opt_unix_socket=0; static char *opt_unix_socket=0;
static uint opt_port; static unsigned int opt_port;
static my_bool tty_password=0; static my_bool tty_password=0;
static MYSQL *mysql=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"); \ #define myheader(str) { fprintf(stdout,"\n\n#######################\n"); \
printf("%s",str); \ fprintf(stdout,"%s",str); \
printf("\n#######################\n"); \ fprintf(stdout,"\n#######################\n"); \
} }
#define init_bind(x) (bzero(x,sizeof(x))) #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) 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) 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 myerror(msg) print_error(msg)
#define mysterror(stmt, msg) print_st_error(stmt, msg) #define mysterror(stmt, msg) print_st_error(stmt, msg)
#define myassert(x) if(x) {\ #define myassert(exp) \
fprintf(stderr,"ASSERTION FAILED AT %d@%s\n",__LINE__, __FILE__);\ if(!exp) {\
exit(1);\ client_disconnect(); \
fprintf(stderr,"\n"); \
assert(exp); \
} }
#define myassert_r(x) if(!x) {\ #define myassert_r(exp) \
fprintf(stderr,"ASSERTION FAILED AT %d@%s\n",__LINE__, __FILE__);\ if(exp) {\
exit(1);\ client_disconnect(); \
fprintf(stderr,"\n"); \
assert(!(exp)); \
} }
#define myquery(r) \ #define myquery(r) \
if( r != 0) \
{ \ { \
if( r || r == -1) \
myerror(NULL); \ myerror(NULL); \
myassert(true);\ myassert(r == 0); \
} }
#define myquery_r(r) \ #define myquery_r(r) \
if( r != 0) \
{ \ { \
if( r || r == -1) \
myerror(NULL); \ myerror(NULL); \
myassert_r(true);\ myassert_r(r == 0); \
} }
#define mystmt(stmt,r) \ #define mystmt(stmt,r) \
if( r != 0) \
{ \ { \
if( r || r == -1) \
mysterror(stmt,NULL); \ mysterror(stmt,NULL); \
myassert(true);\ myassert(r == 0);\
} }
#define myxquery(stmt) \ #define mystmt_r(stmt,r) \
if( stmt == 0) \
{ \ { \
myerror(NULL); \ if( r || r == -1) \
myassert(true);\ mysterror(stmt,NULL); \
myassert_r(r == 0);\
} }
#define myxquery_r(stmt) \ #define mystmt_init(stmt) \
if( stmt == 0) \
{ \ { \
if( stmt == 0) \
myerror(NULL); \ myerror(NULL); \
myassert_r(true);\ myassert(stmt != 0); \
} \ }
else myassert(true);
#define mystmt_r(stmt,r) \ #define mystmt_init_r(stmt) \
if( r != 0) \
{ \ { \
mysterror(stmt,NULL); \ myassert(stmt == 0);\
myassert_r(true);\ }
}
#define mytest(x) if(!x) {myerror(NULL);myassert(true);} #define mytest(x) if(!x) {myerror(NULL);myassert(true);}
#define mytest_r(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 * * connect to the server *
*********************************************************/ *********************************************************/
static void client_connect() static void client_connect()
{ {
char buff[255];
myheader("client_connect"); myheader("client_connect");
if(!(mysql = mysql_init(NULL))) if(!(mysql = mysql_init(NULL)))
...@@ -163,28 +181,37 @@ static void client_connect() ...@@ -163,28 +181,37 @@ static void client_connect()
opt_password, opt_db ? opt_db:"test", opt_port, opt_password, opt_db ? opt_db:"test", opt_port,
opt_unix_socket, 0))) opt_unix_socket, 0)))
{ {
myerror("connection failed"); myerror("connection failed");
mysql_close(mysql);
exit(0); exit(0);
} }
/* set AUTOCOMMIT to ON*/ /* set AUTOCOMMIT to ON*/
mysql_autocommit(mysql, true); 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 * * close the connection *
*********************************************************/ *********************************************************/
void client_disconnect() static void client_disconnect()
{ {
myheader("client_disconnect"); if (mysql)
{
mysql_close(mysql); char buff[255];
sprintf(buff,"DROP DATABASE IF EXISTS %s", current_db);
mysql_query(mysql, buff);
mysql_close(mysql);
}
} }
/******************************************************** /********************************************************
* query processing * * query processing *
*********************************************************/ *********************************************************/
void client_query() static void client_query()
{ {
int rc; int rc;
...@@ -222,7 +249,7 @@ void client_query() ...@@ -222,7 +249,7 @@ void client_query()
/******************************************************** /********************************************************
* print dashes * * print dashes *
*********************************************************/ *********************************************************/
void my_print_dashes(MYSQL_RES *result) static void my_print_dashes(MYSQL_RES *result)
{ {
MYSQL_FIELD *field; MYSQL_FIELD *field;
unsigned int i,j; unsigned int i,j;
...@@ -244,7 +271,7 @@ void my_print_dashes(MYSQL_RES *result) ...@@ -244,7 +271,7 @@ void my_print_dashes(MYSQL_RES *result)
/******************************************************** /********************************************************
* print resultset metadata information * * print resultset metadata information *
*********************************************************/ *********************************************************/
void my_print_result_metadata(MYSQL_RES *result) static void my_print_result_metadata(MYSQL_RES *result)
{ {
MYSQL_FIELD *field; MYSQL_FIELD *field;
unsigned int i,j; unsigned int i,j;
...@@ -287,6 +314,9 @@ int my_process_result_set(MYSQL_RES *result) ...@@ -287,6 +314,9 @@ int my_process_result_set(MYSQL_RES *result)
MYSQL_FIELD *field; MYSQL_FIELD *field;
unsigned int i; unsigned int i;
unsigned int row_count=0; unsigned int row_count=0;
if (!result)
return 0;
my_print_result_metadata(result); my_print_result_metadata(result);
...@@ -313,50 +343,157 @@ int my_process_result_set(MYSQL_RES *result) ...@@ -313,50 +343,157 @@ int my_process_result_set(MYSQL_RES *result)
my_print_dashes(result); my_print_dashes(result);
if (mysql_errno(mysql) != 0) if (mysql_errno(mysql) != 0)
fprintf(stderr, "\n\tmysql_fetch_row() failed\n"); fprintf(stderr, "\n mysql_fetch_row() failed\n");
else else
fprintf(stdout,"\n\t%d rows returned\n", row_count); fprintf(stdout,"\n %d rows returned", row_count);
return(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; int field_count;
MYSQL_BIND bind[1]; uint row_count= 0;
char data[255]; MYSQL_BIND buffer[50];
int rc; MYSQL_FIELD *field;
MYSQL_RES *result;
init_bind(bind); char data[50][255];
long length[50];
int rc, i;
if (!(result= mysql_prepare_result(stmt)))
{
while (!mysql_fetch(stmt));
return 0;
}
bind[0].buffer_type=FIELD_TYPE_STRING; field_count= stmt->field_count;
bind[0].buffer= (char *)data; for(i=0; i < field_count; i++)
bind[0].buffer_length= sizeof(data); {
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); rc= mysql_bind_result(stmt,buffer);
stmt = mysql_prepare(mysql, query, strlen(query)); mystmt(stmt,rc);
myxquery(stmt);
rc = mysql_bind_result(stmt,bind); mysql_field_seek(result, 0);
mystmt(stmt, rc); while (mysql_fetch(stmt) == 0)
{
fputc('\t',stdout);
fputc('|',stdout);
rc = mysql_execute(stmt); for (i=0; i < field_count; i++)
mystmt(stmt, rc); {
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);
rc = mysql_fetch(stmt); return row_count;
mystmt(stmt,rc); }
/*
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);
printf("\n data : %s (expected: %s)",data, exp_data); fprintf(stdout,"\n %s", query);
assert(strcmp(data,exp_data)==0); rc = mysql_query(mysql, query);
myquery(rc);
mysql_stmt_close(stmt); 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 * * store result processing *
*********************************************************/ *********************************************************/
void client_store_result() static void client_store_result()
{ {
MYSQL_RES *result; MYSQL_RES *result;
int rc; int rc;
...@@ -375,9 +512,9 @@ void client_store_result() ...@@ -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; MYSQL_RES *result;
int rc; int rc;
...@@ -398,7 +535,7 @@ void client_use_result() ...@@ -398,7 +535,7 @@ void client_use_result()
/******************************************************** /********************************************************
* query processing * * query processing *
*********************************************************/ *********************************************************/
void test_debug_example() static void test_debug_example()
{ {
int rc; int rc;
MYSQL_RES *result; MYSQL_RES *result;
...@@ -418,7 +555,7 @@ void test_debug_example() ...@@ -418,7 +555,7 @@ void test_debug_example()
rc = mysql_query(mysql,"UPDATE test_debug_example SET name='updated' WHERE name='deleted'"); rc = mysql_query(mysql,"UPDATE test_debug_example SET name='updated' WHERE name='deleted'");
myquery(rc); 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); myquery(rc);
result = mysql_use_result(mysql); result = mysql_use_result(mysql);
...@@ -434,7 +571,7 @@ void test_debug_example() ...@@ -434,7 +571,7 @@ void test_debug_example()
/******************************************************** /********************************************************
* to test autocommit feature * * to test autocommit feature *
*********************************************************/ *********************************************************/
void test_tran_bdb() static void test_tran_bdb()
{ {
MYSQL_RES *result; MYSQL_RES *result;
MYSQL_ROW row; MYSQL_ROW row;
...@@ -512,7 +649,7 @@ void test_tran_bdb() ...@@ -512,7 +649,7 @@ void test_tran_bdb()
/******************************************************** /********************************************************
* to test autocommit feature * * to test autocommit feature *
*********************************************************/ *********************************************************/
void test_tran_innodb() static void test_tran_innodb()
{ {
MYSQL_RES *result; MYSQL_RES *result;
MYSQL_ROW row; MYSQL_ROW row;
...@@ -591,10 +728,10 @@ void test_tran_innodb() ...@@ -591,10 +728,10 @@ void test_tran_innodb()
To test simple prepares of all DML statements To test simple prepares of all DML statements
*********************************************************/ *********************************************************/
void test_prepare_simple() static void test_prepare_simple()
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
int rc,param_count; int rc;
myheader("test_prepare_simple"); myheader("test_prepare_simple");
...@@ -610,41 +747,33 @@ void test_prepare_simple() ...@@ -610,41 +747,33 @@ void test_prepare_simple()
/* alter table */ /* alter table */
strcpy(query,"ALTER TABLE test_prepare_simple ADD new char(20)"); strcpy(query,"ALTER TABLE test_prepare_simple ADD new char(20)");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,0);
fprintf(stdout,"\n total parameters in alter:%d\n", param_count);
assert(param_count == 0);
mysql_stmt_close(stmt); mysql_stmt_close(stmt);
/* insert */ /* insert */
strcpy(query,"INSERT INTO test_prepare_simple VALUES(?,?)"); strcpy(query,"INSERT INTO test_prepare_simple VALUES(?,?)");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,2);
fprintf(stdout,"\n total parameters in insert:%d\n", param_count);
assert(param_count == 2);
mysql_stmt_close(stmt); mysql_stmt_close(stmt);
/* update */ /* update */
strcpy(query,"UPDATE test_prepare_simple SET id=? WHERE id=? AND name= ?"); strcpy(query,"UPDATE test_prepare_simple SET id=? WHERE id=? AND name= ?");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,3);
fprintf(stdout,"\n total parameters in update:%d\n", param_count);
assert(param_count == 3);
mysql_stmt_close(stmt); mysql_stmt_close(stmt);
/* delete */ /* delete */
strcpy(query,"DELETE FROM test_prepare_simple WHERE id=10"); strcpy(query,"DELETE FROM test_prepare_simple WHERE id=10");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,0);
fprintf(stdout,"\n total parameters in delete:%d\n", param_count);
assert(param_count == 0);
rc = mysql_execute(stmt); rc = mysql_execute(stmt);
mystmt(stmt, rc); mystmt(stmt, rc);
...@@ -653,11 +782,9 @@ void test_prepare_simple() ...@@ -653,11 +782,9 @@ void test_prepare_simple()
/* delete */ /* delete */
strcpy(query,"DELETE FROM test_prepare_simple WHERE id=?"); strcpy(query,"DELETE FROM test_prepare_simple WHERE id=?");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,1);
fprintf(stdout,"\n total parameters in delete:%d\n", param_count);
assert(param_count == 1);
rc = mysql_execute(stmt); rc = mysql_execute(stmt);
mystmt_r(stmt, rc); mystmt_r(stmt, rc);
...@@ -666,11 +793,9 @@ void test_prepare_simple() ...@@ -666,11 +793,9 @@ void test_prepare_simple()
/* select */ /* select */
strcpy(query,"SELECT * FROM test_prepare_simple WHERE id=? AND name= ?"); strcpy(query,"SELECT * FROM test_prepare_simple WHERE id=? AND name= ?");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,2);
fprintf(stdout,"\n total parameters in select:%d\n", param_count);
assert(param_count == 2);
mysql_stmt_close(stmt); mysql_stmt_close(stmt);
...@@ -683,9 +808,10 @@ void test_prepare_simple() ...@@ -683,9 +808,10 @@ void test_prepare_simple()
/******************************************************** /********************************************************
* to test simple prepare field results * * to test simple prepare field results *
*********************************************************/ *********************************************************/
void test_prepare_field_result() static void test_prepare_field_result()
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
MYSQL_RES *result;
int rc,param_count; int rc,param_count;
myheader("test_prepare_field_result"); myheader("test_prepare_field_result");
...@@ -696,29 +822,47 @@ void test_prepare_field_result() ...@@ -696,29 +822,47 @@ void test_prepare_field_result()
rc = mysql_commit(mysql); rc = mysql_commit(mysql);
myquery(rc); 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); myquery(rc);
/* insert */ /* 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)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,1);
fprintf(stdout,"\n total parameters in insert:%d\n", param_count);
assert(param_count == 1);
mysql_stmt_close(stmt);
/* now fetch the results ..*/ result = mysql_prepare_result(stmt);
rc = mysql_commit(mysql); mytest(result);
myquery(rc);
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);
} }
/******************************************************** /********************************************************
* to test simple prepare field results * * to test simple prepare field results *
*********************************************************/ *********************************************************/
void test_prepare_syntax() static void test_prepare_syntax()
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
int rc; int rc;
...@@ -736,11 +880,11 @@ void test_prepare_syntax() ...@@ -736,11 +880,11 @@ void test_prepare_syntax()
strcpy(query,"INSERT INTO test_prepare_syntax VALUES(?"); strcpy(query,"INSERT INTO test_prepare_syntax VALUES(?");
stmt = mysql_prepare(mysql, query, strlen(query)); 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"); strcpy(query,"SELECT id,name FROM test_prepare_syntax WHERE id=? AND WHERE");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery_r(stmt); mystmt_init_r(stmt);
/* now fetch the results ..*/ /* now fetch the results ..*/
rc = mysql_commit(mysql); rc = mysql_commit(mysql);
...@@ -751,10 +895,10 @@ void test_prepare_syntax() ...@@ -751,10 +895,10 @@ void test_prepare_syntax()
/******************************************************** /********************************************************
* to test simple prepare * * to test simple prepare *
*********************************************************/ *********************************************************/
void test_prepare() static void test_prepare()
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
int rc,param_count; int rc;
char query[200]; char query[200];
int int_data; int int_data;
char str_data[50]; char str_data[50];
...@@ -779,7 +923,7 @@ void test_prepare() ...@@ -779,7 +923,7 @@ void test_prepare()
myquery(rc); myquery(rc);
rc = mysql_query(mysql,"CREATE TABLE my_prepare(col1 tinyint,\ rc = mysql_query(mysql,"CREATE TABLE my_prepare(col1 tinyint,\
col2 varchar(50), col3 int,\ col2 varchar(15), col3 int,\
col4 smallint, col5 bigint, \ col4 smallint, col5 bigint, \
col6 float, col7 double )"); col6 float, col7 double )");
myquery(rc); myquery(rc);
...@@ -787,11 +931,9 @@ void test_prepare() ...@@ -787,11 +931,9 @@ void test_prepare()
/* insert by prepare */ /* insert by prepare */
strcpy(query,"INSERT INTO my_prepare VALUES(?,?,?,?,?,?,?)"); strcpy(query,"INSERT INTO my_prepare VALUES(?,?,?,?,?,?,?)");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,7);
fprintf(stdout," total parameters in insert:%d\n", param_count);
assert(param_count == 7);
/* tinyint */ /* tinyint */
bind[0].buffer_type=FIELD_TYPE_TINY; bind[0].buffer_type=FIELD_TYPE_TINY;
...@@ -852,7 +994,7 @@ void test_prepare() ...@@ -852,7 +994,7 @@ void test_prepare()
result = mysql_store_result(mysql); result = mysql_store_result(mysql);
mytest(result); mytest(result);
assert((int)tiny_data == my_process_result_set(result)); myassert((int)tiny_data == my_process_result_set(result));
mysql_free_result(result); mysql_free_result(result);
} }
...@@ -860,10 +1002,10 @@ void test_prepare() ...@@ -860,10 +1002,10 @@ void test_prepare()
/******************************************************** /********************************************************
* to test double comparision * * to test double comparision *
*********************************************************/ *********************************************************/
void test_double_compare() static void test_double_compare()
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
int rc,param_count; int rc;
char query[200],real_data[10], tiny_data; char query[200],real_data[10], tiny_data;
double double_data; double double_data;
MYSQL_RES *result; MYSQL_RES *result;
...@@ -890,10 +1032,9 @@ void test_double_compare() ...@@ -890,10 +1032,9 @@ void test_double_compare()
strcpy(query, "UPDATE test_double_compare SET col1=100 WHERE col1 = ? AND col2 = ? AND COL3 = ?"); strcpy(query, "UPDATE test_double_compare SET col1=100 WHERE col1 = ? AND col2 = ? AND COL3 = ?");
stmt = mysql_prepare(mysql,query, strlen(query)); stmt = mysql_prepare(mysql,query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,3);
fprintf(stdout," total parameters in update:%d\n", param_count);
/* tinyint */ /* tinyint */
bind[0].buffer_type=FIELD_TYPE_TINY; bind[0].buffer_type=FIELD_TYPE_TINY;
...@@ -916,7 +1057,7 @@ void test_double_compare() ...@@ -916,7 +1057,7 @@ void test_double_compare()
mystmt(stmt, rc); mystmt(stmt, rc);
rc = (int)mysql_affected_rows(mysql); 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); mysql_stmt_close(stmt);
...@@ -932,21 +1073,17 @@ void test_double_compare() ...@@ -932,21 +1073,17 @@ void test_double_compare()
result = mysql_store_result(mysql); result = mysql_store_result(mysql);
mytest(result); mytest(result);
assert((int)tiny_data == my_process_result_set(result)); myassert((int)tiny_data == my_process_result_set(result));
mysql_free_result(result); mysql_free_result(result);
} }
/******************************************************** /********************************************************
* to test simple null * * to test simple null *
*********************************************************/ *********************************************************/
void test_null() static void test_null()
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
int rc,param_count; int rc;
int nData=1; int nData=1;
MYSQL_RES *result; MYSQL_RES *result;
MYSQL_BIND bind[2]; MYSQL_BIND bind[2];
...@@ -966,15 +1103,13 @@ void test_null() ...@@ -966,15 +1103,13 @@ void test_null()
/* insert by prepare, wrong column name */ /* insert by prepare, wrong column name */
strcpy(query,"INSERT INTO test_null(col3,col2) VALUES(?,?)"); strcpy(query,"INSERT INTO test_null(col3,col2) VALUES(?,?)");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery_r(stmt); mystmt_init_r(stmt);
strcpy(query,"INSERT INTO test_null(col1,col2) VALUES(?,?)"); strcpy(query,"INSERT INTO test_null(col1,col2) VALUES(?,?)");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,2);
fprintf(stdout," total parameters in insert:%d\n", param_count);
assert(param_count == 2);
bind[0].is_null=1; bind[0].is_null=1;
bind[0].buffer_type=MYSQL_TYPE_NULL; bind[0].buffer_type=MYSQL_TYPE_NULL;
...@@ -1003,77 +1138,145 @@ void test_null() ...@@ -1003,77 +1138,145 @@ void test_null()
result = mysql_store_result(mysql); result = mysql_store_result(mysql);
mytest(result); mytest(result);
assert(nData == my_process_result_set(result)); myassert(nData == my_process_result_set(result));
mysql_free_result(result); mysql_free_result(result);
} }
/******************************************************** /********************************************************
* to test simple select * * to test fetch null *
*********************************************************/ *********************************************************/
void test_select_simple() static void test_fetch_null()
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
int rc,length; int rc;
const char query[100]; const char query[100];
MYSQL_RES *result; int length[11], i, nData;
MYSQL_BIND bind[11];
myheader("test_select_simple"); myheader("test_fetch_null");
/* insert by prepare */ init_bind(bind);
strcpy((char *)query, "SHOW TABLES FROM mysql"); 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)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
length = mysql_param_count(stmt); rc = mysql_bind_result(stmt,bind);
fprintf(stdout," total parameters in select:%d\n", length); mystmt(stmt, rc);
assert(length == 0);
rc = mysql_execute(stmt); rc = mysql_execute(stmt);
mystmt(stmt, rc); mystmt(stmt, rc);
/* get the result */ rc = mysql_fetch(stmt);
result = mysql_store_result(mysql); mystmt(stmt,rc);
mytest(result);
my_process_result_set(result); for (i=0; i < 10; i++)
mysql_free_result(result); {
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); mysql_stmt_close(stmt);
}
#if 0 /********************************************************
strcpy((char *)query , "SELECT @@ VERSION"); * to test simple select *
length = strlen(query); *********************************************************/
rc = mysql_query(mysql,query); static void test_select_version()
myquery(rc); {
MYSQL_STMT *stmt;
int rc;
const char query[100];
/* get the result */ myheader("test_select_version");
result = mysql_store_result(mysql);
mytest(result);
my_process_result_set(result); strcpy((char *)query , "SELECT @@version");
mysql_free_result(result); stmt = PREPARE(mysql, query);
#endif 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 * * to test simple select *
*********************************************************/ *********************************************************/
void test_select() static void test_select_simple()
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
int rc,param_count=0; int rc;
char *szData=(char *)"updated-value"; const char query[100];
int nData=1;
MYSQL_BIND bind[2];
MYSQL_RES *result;
myheader("test_select_simple");
myheader("test_select"); /* insert by prepare */
strcpy((char *)query, "SHOW TABLES FROM mysql");
stmt = mysql_prepare(mysql, query, strlen(query));
mystmt_init(stmt);
init_bind(bind); 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 to debug *
*********************************************************/
static void test_select_direct()
{
int rc;
MYSQL_RES *result;
myheader("test_select_direct");
rc = mysql_autocommit(mysql,true); rc = mysql_autocommit(mysql,true);
myquery(rc); myquery(rc);
...@@ -1083,115 +1286,253 @@ void test_select() ...@@ -1083,115 +1286,253 @@ void test_select()
rc = mysql_commit(mysql); rc = mysql_commit(mysql);
myquery(rc); myquery(rc);
rc = mysql_query(mysql,"CREATE TABLE test_select(id int,name varchar(50))"); rc = mysql_query(mysql,"CREATE TABLE test_select(id int, id1 tinyint, \
id2 float, \
id3 double, \
name varchar(50))");
myquery(rc); myquery(rc);
rc = mysql_commit(mysql); rc = mysql_commit(mysql);
myquery(rc); myquery(rc);
/* insert a row and commit the transaction */ /* insert a row and commit the transaction */
rc = mysql_query(mysql,"INSERT INTO test_select VALUES(10,'venu')"); rc = mysql_query(mysql,"INSERT INTO test_select VALUES(10,5,2.3,4.5,'venu')");
myquery(rc); myquery(rc);
rc = mysql_commit(mysql); rc = mysql_commit(mysql);
myquery(rc); myquery(rc);
/* now insert the second row, and rollback the transaction */ rc = mysql_query(mysql,"SELECT * FROM test_select");
rc = mysql_query(mysql,"INSERT INTO test_select VALUES(20,'mysql')");
myquery(rc);
rc = mysql_commit(mysql);
myquery(rc); myquery(rc);
strcpy(query,"SELECT * FROM test_select WHERE id=? AND name=?");
stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt);
param_count = mysql_param_count(stmt);
fprintf(stdout," total parameters in select:%d\n", param_count);
assert(param_count == 2);
/* string data */
nData=10;
szData=(char *)"venu";
bind[1].buffer_type=FIELD_TYPE_STRING;
bind[1].buffer=szData;
bind[1].buffer_length=4;
bind[0].buffer=(gptr)&nData;
bind[0].buffer_type=FIELD_TYPE_LONG;
rc = mysql_bind_param(stmt,bind);
mystmt(stmt, rc);
rc = mysql_execute(stmt);
mystmt(stmt, rc);
/* get the result */ /* get the result */
result = mysql_store_result(mysql); result = mysql_store_result(mysql);
mytest(result); mytest(result);
assert( 1 == my_process_result_set(result)); my_process_result_set(result);
mysql_free_result(result); mysql_free_result(result);
mysql_stmt_close(stmt);
/* bit complicated SELECT */
} }
/******************************************************** /********************************************************
* to test simple update * * to test simple select with prepare *
*********************************************************/ *********************************************************/
void test_simple_update() static void test_select_prepare()
{ {
int rc, count;
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
int rc,param_count;
char szData[25];
int nData=1;
MYSQL_RES *result;
MYSQL_BIND bind[2];
myheader("test_simple_update");
init_bind(bind); myheader("test_select_prepare");
rc = mysql_autocommit(mysql,true); rc = mysql_autocommit(mysql,true);
myquery(rc); myquery(rc);
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_update"); rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_select");
myquery(rc); myquery(rc);
rc = mysql_commit(mysql); rc = mysql_commit(mysql);
myquery(rc); myquery(rc);
rc = mysql_query(mysql,"CREATE TABLE test_update(col1 int,\ rc = mysql_query(mysql,"CREATE TABLE test_select(id int, name varchar(50))");
col2 varchar(50), col3 int )");
myquery(rc); myquery(rc);
rc = mysql_commit(mysql); rc = mysql_commit(mysql);
myquery(rc); myquery(rc);
rc = mysql_query(mysql,"INSERT INTO test_update VALUES(1,'MySQL',100)"); /* insert a row and commit the transaction */
rc = mysql_query(mysql,"INSERT INTO test_select VALUES(10,'venu')");
myquery(rc); myquery(rc);
assert(1 == mysql_affected_rows(mysql));
rc = mysql_commit(mysql); rc = mysql_commit(mysql);
myquery(rc); myquery(rc);
/* insert by prepare */ stmt = mysql_prepare(mysql,"SELECT * FROM test_select",50);
strcpy(query,"UPDATE test_update SET col2=? WHERE col1=?"); mystmt_init(stmt);
stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); rc = mysql_execute(stmt);
mystmt(stmt,rc);
param_count = mysql_param_count(stmt); count= my_process_stmt_result(stmt);
fprintf(stdout," total parameters in update:%d\n", param_count);
assert(param_count == 2);
nData=1; rc = mysql_query(mysql,"DROP TABLE test_select");
bind[0].buffer_type=FIELD_TYPE_STRING; myquery(rc);
bind[0].buffer=szData; /* string data */
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 *
*********************************************************/
static void test_select()
{
MYSQL_STMT *stmt;
int rc;
char szData[25];
int nData=1;
MYSQL_BIND bind[2];
myheader("test_select");
init_bind(bind);
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);
/* now insert the second row, and rollback the transaction */
rc = mysql_query(mysql,"INSERT INTO test_select VALUES(20,'mysql')");
myquery(rc);
rc = mysql_commit(mysql);
myquery(rc);
strcpy(query,"SELECT * FROM test_select WHERE id=? AND name=?");
stmt = mysql_prepare(mysql, query, strlen(query));
mystmt_init(stmt);
verify_param_count(stmt,2);
/* string data */
nData=10;
strcpy(szData,(char *)"venu");
bind[1].buffer_type=FIELD_TYPE_STRING;
bind[1].buffer=szData;
bind[1].buffer_length=4;
bind[0].buffer=(gptr)&nData;
bind[0].buffer_type=FIELD_TYPE_LONG;
rc = mysql_bind_param(stmt,bind);
mystmt(stmt, rc);
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);
my_process_result_set(result);
mysql_free_result(result);
mysql_stmt_close(stmt);
}
/********************************************************
* to test simple update *
*********************************************************/
static void test_simple_update()
{
MYSQL_STMT *stmt;
int rc;
char szData[25];
int nData=1;
MYSQL_RES *result;
MYSQL_BIND bind[2];
myheader("test_simple_update");
init_bind(bind);
rc = mysql_autocommit(mysql,true);
myquery(rc);
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_update");
myquery(rc);
rc = mysql_commit(mysql);
myquery(rc);
rc = mysql_query(mysql,"CREATE TABLE test_update(col1 int,\
col2 varchar(50), col3 int )");
myquery(rc);
rc = mysql_commit(mysql);
myquery(rc);
rc = mysql_query(mysql,"INSERT INTO test_update VALUES(1,'MySQL',100)");
myquery(rc);
myassert(1 == mysql_affected_rows(mysql));
rc = mysql_commit(mysql);
myquery(rc);
/* insert by prepare */
strcpy(query,"UPDATE test_update SET col2=? WHERE col1=?");
stmt = mysql_prepare(mysql, query, strlen(query));
mystmt_init(stmt);
verify_param_count(stmt,2);
nData=1;
bind[0].buffer_type=FIELD_TYPE_STRING;
bind[0].buffer=szData; /* string data */
bind[0].buffer_length=sprintf(szData,"updated-data"); bind[0].buffer_length=sprintf(szData,"updated-data");
bind[1].buffer=(gptr)&nData; bind[1].buffer=(gptr)&nData;
bind[1].buffer_type=FIELD_TYPE_LONG; bind[1].buffer_type=FIELD_TYPE_LONG;
...@@ -1201,7 +1542,7 @@ void test_simple_update() ...@@ -1201,7 +1542,7 @@ void test_simple_update()
rc = mysql_execute(stmt); rc = mysql_execute(stmt);
mystmt(stmt, rc); mystmt(stmt, rc);
assert(1 == mysql_affected_rows(mysql)); myassert(1 == mysql_affected_rows(mysql));
mysql_stmt_close(stmt); mysql_stmt_close(stmt);
...@@ -1217,7 +1558,7 @@ void test_simple_update() ...@@ -1217,7 +1558,7 @@ void test_simple_update()
result = mysql_store_result(mysql); result = mysql_store_result(mysql);
mytest(result); mytest(result);
assert(1 == my_process_result_set(result)); myassert(1 == my_process_result_set(result));
mysql_free_result(result); mysql_free_result(result);
} }
...@@ -1225,10 +1566,10 @@ void test_simple_update() ...@@ -1225,10 +1566,10 @@ void test_simple_update()
/******************************************************** /********************************************************
* to test simple long data handling * * to test simple long data handling *
*********************************************************/ *********************************************************/
void test_long_data() static void test_long_data()
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
int rc,param_count, int_data=10; int rc, int_data;
char *data=NullS; char *data=NullS;
MYSQL_RES *result; MYSQL_RES *result;
MYSQL_BIND bind[3]; MYSQL_BIND bind[3];
...@@ -1255,15 +1596,13 @@ void test_long_data() ...@@ -1255,15 +1596,13 @@ void test_long_data()
strcpy(query,"INSERT INTO test_long_data(col1,col2) VALUES(?)"); strcpy(query,"INSERT INTO test_long_data(col1,col2) VALUES(?)");
stmt = mysql_prepare(mysql, query, strlen(query)); 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(?,?,?)"); strcpy(query,"INSERT INTO test_long_data(col1,col2,col3) VALUES(?,?,?)");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,3);
fprintf(stdout," total parameters in insert:%d\n", param_count);
assert(param_count == 3);
bind[0].buffer=(char *)&int_data; bind[0].buffer=(char *)&int_data;
bind[0].buffer_type=FIELD_TYPE_LONG; bind[0].buffer_type=FIELD_TYPE_LONG;
...@@ -1272,7 +1611,7 @@ void test_long_data() ...@@ -1272,7 +1611,7 @@ void test_long_data()
/* Non string or binary type, error */ /* Non string or binary type, error */
bind[1].buffer_type=FIELD_TYPE_LONG; bind[1].buffer_type=FIELD_TYPE_LONG;
rc = mysql_bind_param(stmt,bind); 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); mystmt_r(stmt, rc);
bind[1].buffer_type=FIELD_TYPE_STRING; bind[1].buffer_type=FIELD_TYPE_STRING;
...@@ -1280,36 +1619,37 @@ void test_long_data() ...@@ -1280,36 +1619,37 @@ void test_long_data()
rc = mysql_bind_param(stmt,bind); rc = mysql_bind_param(stmt,bind);
mystmt(stmt, rc); mystmt(stmt, rc);
int_data= 999;
rc = mysql_execute(stmt); rc = mysql_execute(stmt);
fprintf(stdout,"mysql_execute() returned %d\n",rc); fprintf(stdout," mysql_execute() returned %d\n",rc);
assert(rc == MYSQL_NEED_DATA); myassert(rc == MYSQL_NEED_DATA);
data = (char *)"Micheal"; data = (char *)"Micheal";
/* supply data in pieces */ /* 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); mystmt(stmt, rc);
/* try to execute mysql_execute() now, it should return /* try to execute mysql_execute() now, it should return
MYSQL_NEED_DATA as the long data supply is not yet over MYSQL_NEED_DATA as the long data supply is not yet over
*/ */
rc = mysql_execute(stmt); rc = mysql_execute(stmt);
fprintf(stdout,"mysql_execute() returned %d\n",rc); fprintf(stdout," mysql_execute() returned %d\n",rc);
assert(rc == MYSQL_NEED_DATA); myassert(rc == MYSQL_NEED_DATA);
/* append data again ..*/ /* append data again ..*/
/* Indicate end of data */ /* Indicate end of data */
data = (char *)" 'monty' widenius"; data = (char *)" 'monty' Widenius";
rc = mysql_send_long_data(stmt,1,data,17,1); rc = mysql_send_long_data(stmt,1,data,17,1);
mystmt(stmt, rc); 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); mystmt(stmt, rc);
/* execute */ /* execute */
rc = mysql_execute(stmt); rc = mysql_execute(stmt);
fprintf(stdout,"mysql_execute() returned %d\n",rc); fprintf(stdout," mysql_execute() returned %d\n",rc);
mystmt(stmt,rc); mystmt(stmt,rc);
rc = mysql_commit(mysql); rc = mysql_commit(mysql);
...@@ -1323,17 +1663,21 @@ void test_long_data() ...@@ -1323,17 +1663,21 @@ void test_long_data()
result = mysql_store_result(mysql); result = mysql_store_result(mysql);
mytest(result); mytest(result);
assert(1 == my_process_result_set(result)); myassert(1 == my_process_result_set(result));
mysql_free_result(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 * * to test long data (string) handling *
*********************************************************/ *********************************************************/
void test_long_data_str() static void test_long_data_str()
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
int rc,param_count; int rc, i;
char data[255]; char data[255];
long length; long length;
MYSQL_RES *result; MYSQL_RES *result;
...@@ -1360,11 +1704,9 @@ void test_long_data_str() ...@@ -1360,11 +1704,9 @@ void test_long_data_str()
strcpy(query,"INSERT INTO test_long_data_str VALUES(?,?)"); strcpy(query,"INSERT INTO test_long_data_str VALUES(?,?)");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,2);
fprintf(stdout," total parameters in insert:%d\n", param_count);
assert(param_count == 2);
bind[0].buffer = (gptr)&length; bind[0].buffer = (gptr)&length;
bind[0].buffer_type = FIELD_TYPE_LONG; bind[0].buffer_type = FIELD_TYPE_LONG;
...@@ -1377,28 +1719,24 @@ void test_long_data_str() ...@@ -1377,28 +1719,24 @@ void test_long_data_str()
length = 10; length = 10;
rc = mysql_execute(stmt); rc = mysql_execute(stmt);
fprintf(stdout,"mysql_execute() returned %d\n",rc); fprintf(stdout," mysql_execute() returned %d\n",rc);
assert(rc == MYSQL_NEED_DATA); myassert(rc == MYSQL_NEED_DATA);
length = 40; length = 40;
sprintf(data,"MySQL AB"); sprintf(data,"MySQL AB");
/* supply data in pieces */ /* supply data in pieces */
for(i=0; i < 4; i++)
{ {
int i; rc = mysql_send_long_data(stmt,1,(char *)data,5,0);
for(i=0; i < 4; i++) mystmt(stmt, rc);
{
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);
} }
/* 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 */ /* Indiate end of data supply */
rc = mysql_send_long_data(stmt,1,0,0,1); rc = mysql_send_long_data(stmt,1,0,0,1);
...@@ -1406,7 +1744,7 @@ void test_long_data_str() ...@@ -1406,7 +1744,7 @@ void test_long_data_str()
/* execute */ /* execute */
rc = mysql_execute(stmt); rc = mysql_execute(stmt);
fprintf(stdout,"mysql_execute() returned %d\n",rc); fprintf(stdout," mysql_execute() returned %d\n",rc);
mystmt(stmt,rc); mystmt(stmt,rc);
mysql_stmt_close(stmt); mysql_stmt_close(stmt);
...@@ -1422,20 +1760,27 @@ void test_long_data_str() ...@@ -1422,20 +1760,27 @@ void test_long_data_str()
result = mysql_store_result(mysql); result = mysql_store_result(mysql);
mytest(result); mytest(result);
assert(1 == my_process_result_set(result)); myassert(1 == my_process_result_set(result));
mysql_free_result(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 * * to test long data (string) handling *
*********************************************************/ *********************************************************/
void test_long_data_str1() static void test_long_data_str1()
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
int rc,param_count; int rc;
char *data=(char *)"MySQL AB"; char data[255];
int length; int length, i;
MYSQL_RES *result; MYSQL_RES *result;
MYSQL_BIND bind[2]; MYSQL_BIND bind[2];
...@@ -1460,11 +1805,9 @@ void test_long_data_str1() ...@@ -1460,11 +1805,9 @@ void test_long_data_str1()
strcpy(query,"INSERT INTO test_long_data_str VALUES(?,?)"); strcpy(query,"INSERT INTO test_long_data_str VALUES(?,?)");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,2);
fprintf(stdout," total parameters in insert:%d\n", param_count);
assert(param_count == 2);
bind[0].buffer=data; /* string data */ bind[0].buffer=data; /* string data */
bind[0].is_long_data=1; /* specify long data suppy during run-time */ bind[0].is_long_data=1; /* specify long data suppy during run-time */
...@@ -1478,44 +1821,41 @@ void test_long_data_str1() ...@@ -1478,44 +1821,41 @@ void test_long_data_str1()
length = 10; length = 10;
rc = mysql_execute(stmt); rc = mysql_execute(stmt);
fprintf(stdout,"mysql_execute() returned %d\n",rc); fprintf(stdout," mysql_execute() returned %d\n",rc);
assert(rc == MYSQL_NEED_DATA); myassert(rc == MYSQL_NEED_DATA);
length = strlen(data); length = sprintf(data,"MySQL AB");
/* supply data in pieces */ /* supply data in pieces */
for(i=0; i < 3; i++)
{ {
int i; rc = mysql_send_long_data(stmt,0,data,length,0);
for(i=0; i < 2; i++) 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); rc = mysql_send_long_data(stmt,1,data,2,0);
mystmt(stmt, rc); 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);
} }
/* 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 */ /* Indiate end of data supply */
rc = mysql_send_long_data(stmt,1,0,0,1); rc = mysql_send_long_data(stmt,1,0,0,1);
mystmt(stmt, rc); mystmt(stmt, rc);
rc = mysql_execute(stmt); rc = mysql_execute(stmt);
fprintf(stdout,"mysql_execute() returned %d\n",rc); fprintf(stdout," mysql_execute() returned %d\n",rc);
assert(rc == MYSQL_NEED_DATA); myassert(rc == MYSQL_NEED_DATA);
rc = mysql_send_long_data(stmt,0,0,0,1); rc = mysql_send_long_data(stmt,0,0,0,1);
mystmt(stmt, rc); mystmt(stmt, rc);
/* execute */ /* execute */
rc = mysql_execute(stmt); rc = mysql_execute(stmt);
fprintf(stdout,"mysql_execute() returned %d\n",rc); fprintf(stdout," mysql_execute() returned %d\n",rc);
mystmt(stmt,rc); mystmt(stmt,rc);
mysql_stmt_close(stmt); mysql_stmt_close(stmt);
...@@ -1531,18 +1871,24 @@ void test_long_data_str1() ...@@ -1531,18 +1871,24 @@ void test_long_data_str1()
result = mysql_store_result(mysql); result = mysql_store_result(mysql);
mytest(result); mytest(result);
assert(1 == my_process_result_set(result)); myassert(1 == my_process_result_set(result));
mysql_free_result(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 * * to test long data (binary) handling *
*********************************************************/ *********************************************************/
void test_long_data_bin() static void test_long_data_bin()
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
int rc,param_count; int rc;
char data[255]; char data[255];
int length; int length;
MYSQL_RES *result; MYSQL_RES *result;
...@@ -1569,11 +1915,9 @@ void test_long_data_bin() ...@@ -1569,11 +1915,9 @@ void test_long_data_bin()
strcpy(query,"INSERT INTO test_long_data_bin VALUES(?,?)"); strcpy(query,"INSERT INTO test_long_data_bin VALUES(?,?)");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,2);
fprintf(stdout," total parameters in insert:%d\n", param_count);
assert(param_count == 2);
bind[0].buffer = (gptr)&length; bind[0].buffer = (gptr)&length;
bind[0].buffer_type = FIELD_TYPE_LONG; bind[0].buffer_type = FIELD_TYPE_LONG;
...@@ -1586,8 +1930,8 @@ void test_long_data_bin() ...@@ -1586,8 +1930,8 @@ void test_long_data_bin()
length = 10; length = 10;
rc = mysql_execute(stmt); rc = mysql_execute(stmt);
fprintf(stdout,"mysql_execute() returned %d\n",rc); fprintf(stdout," mysql_execute() returned %d\n",rc);
assert(rc == MYSQL_NEED_DATA); myassert(rc == MYSQL_NEED_DATA);
sprintf(data,"MySQL AB"); sprintf(data,"MySQL AB");
...@@ -1604,8 +1948,8 @@ void test_long_data_bin() ...@@ -1604,8 +1948,8 @@ void test_long_data_bin()
MYSQL_NEED_DATA as the long data supply is not yet over MYSQL_NEED_DATA as the long data supply is not yet over
*/ */
rc = mysql_execute(stmt); rc = mysql_execute(stmt);
fprintf(stdout,"mysql_execute() returned %d\n",rc); fprintf(stdout," mysql_execute() returned %d\n",rc);
assert(rc == MYSQL_NEED_DATA); myassert(rc == MYSQL_NEED_DATA);
} }
/* Indiate end of data supply */ /* Indiate end of data supply */
...@@ -1614,7 +1958,7 @@ void test_long_data_bin() ...@@ -1614,7 +1958,7 @@ void test_long_data_bin()
/* execute */ /* execute */
rc = mysql_execute(stmt); rc = mysql_execute(stmt);
fprintf(stdout,"mysql_execute() returned %d\n",rc); fprintf(stdout," mysql_execute() returned %d\n",rc);
mystmt(stmt,rc); mystmt(stmt,rc);
mysql_stmt_close(stmt); mysql_stmt_close(stmt);
...@@ -1630,7 +1974,7 @@ void test_long_data_bin() ...@@ -1630,7 +1974,7 @@ void test_long_data_bin()
result = mysql_store_result(mysql); result = mysql_store_result(mysql);
mytest(result); mytest(result);
assert(1 == my_process_result_set(result)); myassert(1 == my_process_result_set(result));
mysql_free_result(result); mysql_free_result(result);
} }
...@@ -1638,10 +1982,10 @@ void test_long_data_bin() ...@@ -1638,10 +1982,10 @@ void test_long_data_bin()
/******************************************************** /********************************************************
* to test simple delete * * to test simple delete *
*********************************************************/ *********************************************************/
void test_simple_delete() static void test_simple_delete()
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
int rc,param_count; int rc;
char szData[30]={0}; char szData[30]={0};
int nData=1; int nData=1;
MYSQL_RES *result; MYSQL_RES *result;
...@@ -1670,7 +2014,7 @@ void test_simple_delete() ...@@ -1670,7 +2014,7 @@ void test_simple_delete()
rc = mysql_query(mysql,"INSERT INTO test_simple_delete VALUES(1,'MySQL',100)"); rc = mysql_query(mysql,"INSERT INTO test_simple_delete VALUES(1,'MySQL',100)");
myquery(rc); myquery(rc);
assert(1 == mysql_affected_rows(mysql)); myassert(1 == mysql_affected_rows(mysql));
rc = mysql_commit(mysql); rc = mysql_commit(mysql);
myquery(rc); myquery(rc);
...@@ -1678,11 +2022,9 @@ void test_simple_delete() ...@@ -1678,11 +2022,9 @@ void test_simple_delete()
/* insert by prepare */ /* insert by prepare */
strcpy(query,"DELETE FROM test_simple_delete WHERE col1=? AND col2=? AND col3=100"); strcpy(query,"DELETE FROM test_simple_delete WHERE col1=? AND col2=? AND col3=100");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,2);
fprintf(stdout," total parameters in delete:%d\n", param_count);
assert(param_count == 2);
nData=1; nData=1;
strcpy(szData,"MySQL"); strcpy(szData,"MySQL");
...@@ -1697,7 +2039,7 @@ void test_simple_delete() ...@@ -1697,7 +2039,7 @@ void test_simple_delete()
rc = mysql_execute(stmt); rc = mysql_execute(stmt);
mystmt(stmt, rc); mystmt(stmt, rc);
assert(1 == mysql_affected_rows(mysql)); myassert(1 == mysql_affected_rows(mysql));
mysql_stmt_close(stmt); mysql_stmt_close(stmt);
...@@ -1713,7 +2055,7 @@ void test_simple_delete() ...@@ -1713,7 +2055,7 @@ void test_simple_delete()
result = mysql_store_result(mysql); result = mysql_store_result(mysql);
mytest(result); mytest(result);
assert(0 == my_process_result_set(result)); myassert(0 == my_process_result_set(result));
mysql_free_result(result); mysql_free_result(result);
} }
...@@ -1722,10 +2064,10 @@ void test_simple_delete() ...@@ -1722,10 +2064,10 @@ void test_simple_delete()
/******************************************************** /********************************************************
* to test simple update * * to test simple update *
*********************************************************/ *********************************************************/
void test_update() static void test_update()
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
int rc,param_count; int rc;
char szData[25]; char szData[25];
int nData=1; int nData=1;
MYSQL_RES *result; MYSQL_RES *result;
...@@ -1753,11 +2095,9 @@ void test_update() ...@@ -1753,11 +2095,9 @@ void test_update()
strcpy(query,"INSERT INTO test_update(col2,col3) VALUES(?,?)"); strcpy(query,"INSERT INTO test_update(col2,col3) VALUES(?,?)");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,2);
fprintf(stdout," total parameters in insert:%d\n", param_count);
assert(param_count == 2);
/* string data */ /* string data */
bind[0].buffer_type=FIELD_TYPE_STRING; bind[0].buffer_type=FIELD_TYPE_STRING;
...@@ -1773,16 +2113,14 @@ void test_update() ...@@ -1773,16 +2113,14 @@ void test_update()
rc = mysql_execute(stmt); rc = mysql_execute(stmt);
mystmt(stmt, rc); mystmt(stmt, rc);
assert(1 == mysql_affected_rows(mysql)); myassert(1 == mysql_affected_rows(mysql));
mysql_stmt_close(stmt); mysql_stmt_close(stmt);
strcpy(query,"UPDATE test_update SET col2=? WHERE col3=?"); strcpy(query,"UPDATE test_update SET col2=? WHERE col3=?");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,2);
fprintf(stdout," total parameters in update:%d\n", param_count);
assert(param_count == 2);
nData=100; nData=100;
...@@ -1797,7 +2135,7 @@ void test_update() ...@@ -1797,7 +2135,7 @@ void test_update()
rc = mysql_execute(stmt); rc = mysql_execute(stmt);
mystmt(stmt, rc); mystmt(stmt, rc);
assert(1 == mysql_affected_rows(mysql)); myassert(1 == mysql_affected_rows(mysql));
mysql_stmt_close(stmt); mysql_stmt_close(stmt);
...@@ -1813,7 +2151,7 @@ void test_update() ...@@ -1813,7 +2151,7 @@ void test_update()
result = mysql_store_result(mysql); result = mysql_store_result(mysql);
mytest(result); mytest(result);
assert(1 == my_process_result_set(result)); myassert(1 == my_process_result_set(result));
mysql_free_result(result); mysql_free_result(result);
} }
...@@ -1821,13 +2159,13 @@ void test_update() ...@@ -1821,13 +2159,13 @@ void test_update()
/******************************************************** /********************************************************
* to test simple prepare * * to test simple prepare *
*********************************************************/ *********************************************************/
void test_init_prepare() static void test_prepare_noparam()
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
int param_count, rc; int rc;
MYSQL_RES *result; MYSQL_RES *result;
myheader("test_init_prepare"); myheader("test_prepare_noparam");
rc = mysql_query(mysql,"DROP TABLE IF EXISTS my_prepare"); rc = mysql_query(mysql,"DROP TABLE IF EXISTS my_prepare");
myquery(rc); myquery(rc);
...@@ -1842,11 +2180,9 @@ void test_init_prepare() ...@@ -1842,11 +2180,9 @@ void test_init_prepare()
/* insert by prepare */ /* insert by prepare */
strcpy(query,"INSERT INTO my_prepare VALUES(10,'venu')"); strcpy(query,"INSERT INTO my_prepare VALUES(10,'venu')");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,0);
fprintf(stdout," total parameters in insert:%d\n", param_count);
assert(param_count == 0);
rc = mysql_execute(stmt); rc = mysql_execute(stmt);
mystmt(stmt, rc); mystmt(stmt, rc);
...@@ -1865,7 +2201,7 @@ void test_init_prepare() ...@@ -1865,7 +2201,7 @@ void test_init_prepare()
result = mysql_store_result(mysql); result = mysql_store_result(mysql);
mytest(result); mytest(result);
assert(1 == my_process_result_set(result)); myassert(1 == my_process_result_set(result));
mysql_free_result(result); mysql_free_result(result);
} }
...@@ -1873,12 +2209,12 @@ void test_init_prepare() ...@@ -1873,12 +2209,12 @@ void test_init_prepare()
/******************************************************** /********************************************************
* to test simple bind result * * to test simple bind result *
*********************************************************/ *********************************************************/
void test_bind_result() static void test_bind_result()
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
int rc; int rc;
const char query[100]; const char query[100];
int nData; int nData, length, length1;
char szData[100]; char szData[100];
MYSQL_BIND bind[2]; MYSQL_BIND bind[2];
...@@ -1903,6 +2239,9 @@ void test_bind_result() ...@@ -1903,6 +2239,9 @@ void test_bind_result()
rc = mysql_query(mysql,"INSERT INTO test_bind_result VALUES(20,'MySQL')"); rc = mysql_query(mysql,"INSERT INTO test_bind_result VALUES(20,'MySQL')");
myquery(rc); myquery(rc);
rc = mysql_query(mysql,"INSERT INTO test_bind_result(col2) VALUES('monty')");
myquery(rc);
rc = mysql_commit(mysql); rc = mysql_commit(mysql);
myquery(rc); myquery(rc);
...@@ -1910,13 +2249,15 @@ void test_bind_result() ...@@ -1910,13 +2249,15 @@ void test_bind_result()
bind[0].buffer_type=FIELD_TYPE_LONG; bind[0].buffer_type=FIELD_TYPE_LONG;
bind[0].buffer= (gptr) &nData; /* integer data */ bind[0].buffer= (gptr) &nData; /* integer data */
bind[0].length= (long *)&length;
bind[1].buffer_type=FIELD_TYPE_STRING; bind[1].buffer_type=FIELD_TYPE_STRING;
bind[1].buffer=szData; /* string data */ bind[1].buffer=szData; /* string data */
bind[1].buffer_length=sizeof(szData); bind[1].buffer_length=sizeof(szData);
bind[1].length=(long *)&length1;
strcpy((char *)query , "SELECT * FROM test_bind_result"); strcpy((char *)query , "SELECT * FROM test_bind_result");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
rc = mysql_bind_result(stmt,bind); rc = mysql_bind_result(stmt,bind);
mystmt(stmt, rc); mystmt(stmt, rc);
...@@ -1927,74 +2268,441 @@ void test_bind_result() ...@@ -1927,74 +2268,441 @@ void test_bind_result()
rc = mysql_fetch(stmt); rc = mysql_fetch(stmt);
mystmt(stmt,rc); mystmt(stmt,rc);
printf("\n row 1:%d,%s",nData, szData); fprintf(stdout,"\n row 1: %d,%s(%d)",nData, szData, length1);
assert(nData == 10); myassert(nData == 10);
assert(strcmp(szData,"venu")==0); myassert(strcmp(szData,"venu")==0);
myassert(length1 == 4);
rc = mysql_fetch(stmt); rc = mysql_fetch(stmt);
mystmt(stmt,rc); mystmt(stmt,rc);
printf("\n row 2:%d,%s",nData, szData); fprintf(stdout,"\n row 2: %d,%s(%d)",nData, szData, length1);
assert(nData == 20); myassert(nData == 20);
assert(strcmp(szData,"MySQL")==0); 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); rc = mysql_fetch(stmt);
assert(rc == MYSQL_NO_DATA); myassert(rc == MYSQL_NO_DATA);
mysql_stmt_close(stmt); mysql_stmt_close(stmt);
} }
/******************************************************** /********************************************************
* to test simple prepare with all possible types * * to test ext bind result *
*********************************************************/ *********************************************************/
void test_prepare_ext() static void test_bind_result_ext()
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
int rc,param_count; int rc;
char *sql; const char query[100];
int nData=1; uchar t_data;
MYSQL_RES *result; short s_data;
char tData=1; int i_data;
short sData=10; longlong b_data;
longlong bData=20; float f_data;
MYSQL_BIND bind_int[6]; double d_data;
char szData[20], bData[20];
int szLength, bLength;
MYSQL_BIND bind[8];
myheader("test_prepare_ext"); myheader("test_bind_result_ext");
init_bind(bind_int); init_bind(bind);
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_bind_result");
myquery(rc);
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_prepare_ext"); 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); myquery(rc);
rc = mysql_commit(mysql); rc = mysql_commit(mysql);
myquery(rc); myquery(rc);
sql = (char *)"CREATE TABLE test_prepare_ext\ rc = mysql_query(mysql,"INSERT INTO test_bind_result VALUES(19,2999,3999,4999999,\
(\ 2345.6,5678.89563,\
c1 tinyint,\ 'venu','mysql')");
c2 smallint,\ myquery(rc);
c3 mediumint,\
c4 int,\ rc = mysql_commit(mysql);
c5 integer,\ myquery(rc);
c6 bigint,\
c7 float,\ bind[0].buffer_type=MYSQL_TYPE_TINY;
c8 double,\ bind[0].buffer=(gptr)&t_data;
c9 double precision,\
c10 real,\ bind[1].buffer_type=MYSQL_TYPE_SHORT;
c11 decimal(7,4),\ bind[2].buffer_type=MYSQL_TYPE_LONG;
c12 numeric(8,4),\
c13 date,\ bind[3].buffer_type=MYSQL_TYPE_LONGLONG;
c14 datetime,\ bind[1].buffer=(gptr)&s_data;
c15 timestamp(14),\
c16 time,\ bind[2].buffer=(gptr)&i_data;
c17 year,\ bind[3].buffer=(gptr)&b_data;
c18 bit,\
c19 bool,\ bind[4].buffer_type=MYSQL_TYPE_FLOAT;
c20 char,\ bind[4].buffer=(gptr)&f_data;
c21 char(10),\
c22 varchar(30),\ bind[5].buffer_type=MYSQL_TYPE_DOUBLE;
c23 tinyblob,\ bind[5].buffer=(gptr)&d_data;
c24 tinytext,\
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 fetching of date, time and ts *
*********************************************************/
static void test_fetch_date()
{
MYSQL_STMT *stmt;
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;
char tData=1;
short sData=10;
longlong bData=20;
MYSQL_BIND bind_int[6];
myheader("test_prepare_ext");
init_bind(bind_int);
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_prepare_ext");
myquery(rc);
rc = mysql_commit(mysql);
myquery(rc);
sql = (char *)"CREATE TABLE test_prepare_ext\
(\
c1 tinyint,\
c2 smallint,\
c3 mediumint,\
c4 int,\
c5 integer,\
c6 bigint,\
c7 float,\
c8 double,\
c9 double precision,\
c10 real,\
c11 decimal(7,4),\
c12 numeric(8,4),\
c13 date,\
c14 datetime,\
c15 timestamp(14),\
c16 time,\
c17 year,\
c18 bit,\
c19 bool,\
c20 char,\
c21 char(10),\
c22 varchar(30),\
c23 tinyblob,\
c24 tinytext,\
c25 blob,\ c25 blob,\
c26 text,\ c26 text,\
c27 mediumblob,\ c27 mediumblob,\
...@@ -2012,9 +2720,7 @@ void test_prepare_ext() ...@@ -2012,9 +2720,7 @@ void test_prepare_ext()
stmt = mysql_prepare(mysql,query, strlen(query)); stmt = mysql_prepare(mysql,query, strlen(query));
myquery(rc); myquery(rc);
param_count = mysql_param_count(stmt); verify_param_count(stmt,6);
fprintf(stdout," total parameters in insert:%d\n", param_count);
assert(param_count == 6);
/*tinyint*/ /*tinyint*/
bind_int[0].buffer_type=FIELD_TYPE_TINY; bind_int[0].buffer_type=FIELD_TYPE_TINY;
...@@ -2065,7 +2771,7 @@ void test_prepare_ext() ...@@ -2065,7 +2771,7 @@ void test_prepare_ext()
result = mysql_store_result(mysql); result = mysql_store_result(mysql);
mytest(result); mytest(result);
assert(nData == my_process_result_set(result)); myassert(nData == my_process_result_set(result));
mysql_free_result(result); mysql_free_result(result);
} }
...@@ -2075,14 +2781,14 @@ void test_prepare_ext() ...@@ -2075,14 +2781,14 @@ void test_prepare_ext()
/******************************************************** /********************************************************
* to test real and alias names * * to test real and alias names *
*********************************************************/ *********************************************************/
void test_field_names() static void test_field_names()
{ {
int rc; int rc;
MYSQL_RES *result; MYSQL_RES *result;
myheader("test_field_names"); 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"); rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_field_names1");
myquery(rc); myquery(rc);
...@@ -2108,7 +2814,7 @@ void test_field_names() ...@@ -2108,7 +2814,7 @@ void test_field_names()
result = mysql_use_result(mysql); result = mysql_use_result(mysql);
mytest(result); mytest(result);
assert(0 == my_process_result_set(result)); myassert(0 == my_process_result_set(result));
mysql_free_result(result); mysql_free_result(result);
/* with table name included with true column name */ /* with table name included with true column name */
...@@ -2118,23 +2824,20 @@ void test_field_names() ...@@ -2118,23 +2824,20 @@ void test_field_names()
result = mysql_use_result(mysql); result = mysql_use_result(mysql);
mytest(result); mytest(result);
assert(0 == my_process_result_set(result)); myassert(0 == my_process_result_set(result));
mysql_free_result(result); mysql_free_result(result);
} }
/******************************************************** /********************************************************
* to test warnings * * to test warnings *
*********************************************************/ *********************************************************/
void test_warnings() static void test_warnings()
{ {
int rc; int rc;
MYSQL_RES *result; MYSQL_RES *result;
myheader("test_warnings"); myheader("test_warnings");
rc = mysql_query(mysql,"USE test");
myquery(rc);
rc = mysql_query(mysql,"SHOW WARNINGS"); rc = mysql_query(mysql,"SHOW WARNINGS");
myquery(rc); myquery(rc);
...@@ -2148,7 +2851,7 @@ void test_warnings() ...@@ -2148,7 +2851,7 @@ void test_warnings()
/******************************************************** /********************************************************
* to test errors * * to test errors *
*********************************************************/ *********************************************************/
void test_errors() static void test_errors()
{ {
int rc; int rc;
MYSQL_RES *result; MYSQL_RES *result;
...@@ -2170,10 +2873,10 @@ void test_errors() ...@@ -2170,10 +2873,10 @@ void test_errors()
/******************************************************** /********************************************************
* to test simple prepare-insert * * to test simple prepare-insert *
*********************************************************/ *********************************************************/
void test_insert() static void test_insert()
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
int rc,param_count, length; int rc, length;
char query[200]; char query[200];
char str_data[50]; char str_data[50];
char tiny_data; char tiny_data;
...@@ -2199,11 +2902,9 @@ void test_insert() ...@@ -2199,11 +2902,9 @@ void test_insert()
bzero(bind, sizeof(bind)); bzero(bind, sizeof(bind));
strcpy(query,"INSERT INTO test_prep_insert VALUES(?,?)"); strcpy(query,"INSERT INTO test_prep_insert VALUES(?,?)");
stmt = mysql_prepare(mysql, query, strlen(query)); stmt = mysql_prepare(mysql, query, strlen(query));
myxquery(stmt); mystmt_init(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,2);
fprintf(stdout," total parameters in insert:%d\n", param_count);
assert(param_count == 2);
/* tinyint */ /* tinyint */
bind[0].buffer_type=FIELD_TYPE_TINY; bind[0].buffer_type=FIELD_TYPE_TINY;
...@@ -2238,7 +2939,7 @@ void test_insert() ...@@ -2238,7 +2939,7 @@ void test_insert()
result = mysql_store_result(mysql); result = mysql_store_result(mysql);
mytest(result); mytest(result);
assert((int)tiny_data == my_process_result_set(result)); myassert((int)tiny_data == my_process_result_set(result));
mysql_free_result(result); mysql_free_result(result);
} }
...@@ -2246,10 +2947,10 @@ void test_insert() ...@@ -2246,10 +2947,10 @@ void test_insert()
/******************************************************** /********************************************************
* to test simple prepare-resultset info * * to test simple prepare-resultset info *
*********************************************************/ *********************************************************/
void test_prepare_resultset() static void test_prepare_resultset()
{ {
MYSQL_STMT *stmt; MYSQL_STMT *stmt;
int rc,param_count; int rc;
char query[200]; char query[200];
MYSQL_RES *result; MYSQL_RES *result;
...@@ -2268,38 +2969,15 @@ void test_prepare_resultset() ...@@ -2268,38 +2969,15 @@ void test_prepare_resultset()
name varchar(50),extra double)"); name varchar(50),extra double)");
myquery(rc); myquery(rc);
/* insert by prepare */ strcpy(query,"SELECT * FROM test_prepare_resultset");
strcpy(query,"INSERT INTO test_prepare_resultset(id,name) VALUES(?,?)"); stmt = PREPARE(mysql, query);
stmt = mysql_prepare(mysql, query, strlen(query)); mystmt_init(stmt);
myxquery(stmt);
param_count = mysql_param_count(stmt); verify_param_count(stmt,0);
fprintf(stdout," total parameters in insert:%d\n", param_count);
assert(param_count == 2);
rc = mysql_query(mysql,"SELECT * FROM test_prepare_resultset");
myquery(rc);
/* get the prepared-result */
result = mysql_prepare_result(stmt); result = mysql_prepare_result(stmt);
assert( result != 0);
my_print_result_metadata(result);
mysql_free_result(result);
result = mysql_store_result(mysql);
mytest(result); 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); my_print_result_metadata(result);
mysql_free_result(result);
mysql_stmt_close(stmt); mysql_stmt_close(stmt);
} }
...@@ -2307,7 +2985,7 @@ void test_prepare_resultset() ...@@ -2307,7 +2985,7 @@ void test_prepare_resultset()
* to test field flags (verify .NET provider) * * to test field flags (verify .NET provider) *
*********************************************************/ *********************************************************/
void test_field_flags() static void test_field_flags()
{ {
int rc; int rc;
MYSQL_RES *result; MYSQL_RES *result;
...@@ -2348,19 +3026,456 @@ void test_field_flags() ...@@ -2348,19 +3026,456 @@ void test_field_flags()
for(i=0; i< mysql_num_fields(result); i++) for(i=0; i< mysql_num_fields(result); i++)
{ {
field = mysql_fetch_field(result); field = mysql_fetch_field(result);
printf("\nfield:%d",i); fprintf(stdout,"\n field:%d",i);
if(field->flags & NOT_NULL_FLAG) if(field->flags & NOT_NULL_FLAG)
printf("\n NOT_NULL_FLAG"); fprintf(stdout,"\n NOT_NULL_FLAG");
if(field->flags & PRI_KEY_FLAG) if(field->flags & PRI_KEY_FLAG)
printf("\n PRI_KEY_FLAG"); fprintf(stdout,"\n PRI_KEY_FLAG");
if(field->flags & UNIQUE_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) if(field->flags & MULTIPLE_KEY_FLAG)
printf("\n MULTIPLE_KEY_FLAG"); fprintf(stdout,"\n MULTIPLE_KEY_FLAG");
if(field->flags & AUTO_INCREMENT_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); mysql_free_result(result);
} }
...@@ -2398,24 +3513,24 @@ static void usage(void) ...@@ -2398,24 +3513,24 @@ static void usage(void)
puts("and you are welcome to modify and redistribute it under the GPL license\n"); puts("and you are welcome to modify and redistribute it under the GPL license\n");
puts(" Copyright (C) 1995-2002 MySQL AB "); puts(" Copyright (C) 1995-2002 MySQL AB ");
puts("-----------------------------------------------------------------------\n"); puts("-----------------------------------------------------------------------\n");
printf("usage: %s [OPTIONS]\n\n", my_progname); fprintf(stdout,"usage: %s [OPTIONS]\n\n", my_progname);
printf("\ fprintf(stdout,"\
-?, --help Display this help message and exit.\n\ -?, --help Display this help message and exit.\n\
-D --database=... Database name to be used for test.\n\ -D --database=... Database name to be used for test.\n\
-h, --host=... Connect to host.\n\ -h, --host=... Connect to host.\n\
-p, --password[=...] Password to use when connecting to server.\n"); -p, --password[=...] Password to use when connecting to server.\n");
#ifdef __WIN__ #ifdef __WIN__
printf("\ fprintf(stdout,"\
-W, --pipe Use named pipes to connect to server.\n"); -W, --pipe Use named pipes to connect to server.\n");
#endif #endif
printf("\ fprintf(stdout,"\
-P, --port=... Port number to use for connection.\n\ -P, --port=... Port number to use for connection.\n\
-S, --socket=... Socket file to use for connection.\n"); -S, --socket=... Socket file to use for connection.\n");
#ifndef DONT_ALLOW_USER_CHANGE #ifndef DONT_ALLOW_USER_CHANGE
printf("\ fprintf(stdout,"\
-u, --user=# User for login if not current user.\n"); -u, --user=# User for login if not current user.\n");
#endif #endif
printf("*********************************************************************\n"); fprintf(stdout,"*********************************************************************\n");
} }
static my_bool static my_bool
...@@ -2471,24 +3586,52 @@ int main(int argc, char **argv) ...@@ -2471,24 +3586,52 @@ int main(int argc, char **argv)
MY_INIT(argv[0]); MY_INIT(argv[0]);
get_options(argc,argv); 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_null(); /* test null data handling */
test_simple_update(); test_simple_update();
//test_select_simple(); test_prepare_resultset();
//test_prepare_resultset(); test_prepare_noparam();/* prepare without parameters */
//test_select(); /* simple prepare-select */ test_select(); /* simple prepare-select */
test_insert(); /* prepare with insert */ test_insert(); /* prepare with insert */
//test_bind_result(); /* result bind test */ test_bind_result(); /* result bind test */
//test_long_data(); /* long data handling in pieces */ test_long_data(); /* long data handling in pieces */
test_prepare_simple();/* simple prepare */ test_prepare_simple();/* simple prepare */
test_prepare(); /* prepare test */ test_prepare(); /* prepare test */
test_prepare_simple();/* simple prepare */
test_null(); /* test null data handling */ test_null(); /* test null data handling */
test_debug_example(); /* some debugging case */ test_debug_example(); /* some debugging case */
test_update(); /* prepare-update test */ test_update(); /* prepare-update test */
test_simple_update(); /* simple prepare with update */ 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_simple_delete(); /* prepare with delete */
test_field_names(); /* test for field names */ test_field_names(); /* test for field names */
test_double_compare();/* float comparision */ test_double_compare();/* float comparision */
...@@ -2499,20 +3642,23 @@ int main(int argc, char **argv) ...@@ -2499,20 +3642,23 @@ int main(int argc, char **argv)
test_tran_innodb(); /* transaction test on InnoDB table type */ test_tran_innodb(); /* transaction test on InnoDB table type */
test_prepare_ext(); /* test prepare with all types conversion -- TODO */ test_prepare_ext(); /* test prepare with all types conversion -- TODO */
test_prepare_syntax();/* syntax check for prepares */ 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_names(); /* test for field names */
test_field_flags(); /* test to help .NET provider team */ test_field_flags(); /* test to help .NET provider team */
//test_long_data_str(); /* long data handling */ test_long_data_str(); /* long data handling */
//test_long_data_str1();/* yet another long data handling */ test_long_data_str1();/* yet another long data handling */
//test_long_data_bin(); /* long binary insertion */ test_long_data_bin(); /* long binary insertion */
test_warnings(); /* show warnings test */ test_warnings(); /* show warnings test */
test_errors(); /* show errors test */ test_errors(); /* show errors test */
//test_select_simple(); /* simple select prepare */ test_select_simple(); /* simple select prepare */
//test_prepare_resultset();/* prepare meta info test */ 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 */ client_disconnect(); /* disconnect from server */
fprintf(stdout,"\ndone !!!\n"); fprintf(stdout,"\n\nSUCCESS !!!\n");
return(0); return(0);
} }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7