summaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
authorunknown <venu@myvenu.com>2003-01-03 23:38:47 -0800
committerunknown <venu@myvenu.com>2003-01-03 23:38:47 -0800
commit6609f346d6121ee2e6542b82b87f5f4f6924bbda (patch)
treefe1b8d8c751563f6fd046bf6f3d9ce2bfe0dc75e /tests
parent594bfe01bf335c35cedd62a865cfd308fee8ef6e (diff)
downloadmariadb-git-6609f346d6121ee2e6542b82b87f5f4f6924bbda.tar.gz
Prepared statements + binary protocol test update
Diffstat (limited to 'tests')
-rw-r--r--tests/client_test.c1936
1 files changed, 1541 insertions, 395 deletions
diff --git a/tests/client_test.c b/tests/client_test.c
index 280df2bf717..d5e13dd3b43 100644
--- a/tests/client_test.c
+++ b/tests/client_test.c
@@ -32,14 +32,13 @@
#include <stdio.h>
#include <string.h>
-#include <assert.h>
-
-
/* mysql client headers */
#include <my_sys.h>
#include <mysql.h>
#include <my_getopt.h>
+#include <assert.h>
+
#ifndef true
#define true 1
#endif
@@ -58,100 +57,119 @@ static char *opt_user=0;
static char *opt_password=0;
static char *opt_host=0;
static char *opt_unix_socket=0;
-static uint opt_port;
+static unsigned int opt_port;
static my_bool tty_password=0;
static MYSQL *mysql=0;
-static char query[255];
+static char query[255];
+static char current_db[]= "client_test_db";
-#define myheader(str) { printf("\n\n#######################\n"); \
- printf("%s",str); \
- printf("\n#######################\n"); \
+#define myheader(str) { fprintf(stdout,"\n\n#######################\n"); \
+ fprintf(stdout,"%s",str); \
+ fprintf(stdout,"\n#######################\n"); \
}
#define init_bind(x) (bzero(x,sizeof(x)))
-void print_error(const char *msg)
+#ifndef mysql_param_result
+#define mysql_param_result mysql_prepare_result
+#endif
+
+static void print_error(const char *msg)
{
if (mysql)
{
- fprintf(stderr,"\n [MySQL]%s \n",mysql_error(mysql));
+ if (mysql->server_version)
+ fprintf(stderr,"\n [MySQL-%s]",mysql->server_version);
+ else
+ fprintf(stderr,"\n [MySQL]");
+ fprintf(stderr," %s\n",mysql_error(mysql));
}
- else if(msg) fprintf(stderr, "%s\n", msg);
+ else if(msg) fprintf(stderr, " [MySQL] %s\n", msg);
}
-void print_st_error(MYSQL_STMT *stmt, const char *msg)
+static void print_st_error(MYSQL_STMT *stmt, const char *msg)
{
if (stmt)
{
- fprintf(stderr,"\n [MySQL]%s \n",mysql_stmt_error(stmt));
+ if (stmt->mysql && stmt->mysql->server_version)
+ fprintf(stderr,"\n [MySQL-%s]",stmt->mysql->server_version);
+ else
+ fprintf(stderr,"\n [MySQL]");
+
+ fprintf(stderr," %s\n",mysql_stmt_error(stmt));
}
- else if(msg) fprintf(stderr, "%s\n", msg);
+ else if(msg) fprintf(stderr, " [MySQL] %s\n", msg);
}
+static void client_disconnect();
#define myerror(msg) print_error(msg)
#define mysterror(stmt, msg) print_st_error(stmt, msg)
-#define myassert(x) if(x) {\
- fprintf(stderr,"ASSERTION FAILED AT %d@%s\n",__LINE__, __FILE__);\
- exit(1);\
+#define myassert(exp) \
+ if(!exp) {\
+ client_disconnect(); \
+ fprintf(stderr,"\n"); \
+ assert(exp); \
}
-#define myassert_r(x) if(!x) {\
- fprintf(stderr,"ASSERTION FAILED AT %d@%s\n",__LINE__, __FILE__);\
- exit(1);\
+#define myassert_r(exp) \
+ if(exp) {\
+ client_disconnect(); \
+ fprintf(stderr,"\n"); \
+ assert(!(exp)); \
}
#define myquery(r) \
-if( r != 0) \
{ \
+if( r || r == -1) \
myerror(NULL); \
- myassert(true);\
+ myassert(r == 0); \
}
#define myquery_r(r) \
-if( r != 0) \
{ \
+if( r || r == -1) \
myerror(NULL); \
- myassert_r(true);\
+myassert_r(r == 0); \
}
#define mystmt(stmt,r) \
-if( r != 0) \
{ \
+if( r || r == -1) \
mysterror(stmt,NULL); \
- myassert(true);\
+myassert(r == 0);\
}
-#define myxquery(stmt) \
-if( stmt == 0) \
+#define mystmt_r(stmt,r) \
{ \
- myerror(NULL); \
- myassert(true);\
+if( r || r == -1) \
+ mysterror(stmt,NULL); \
+myassert_r(r == 0);\
}
-#define myxquery_r(stmt) \
-if( stmt == 0) \
+#define mystmt_init(stmt) \
{ \
+if( stmt == 0) \
myerror(NULL); \
- myassert_r(true);\
-} \
-else myassert(true);
+myassert(stmt != 0); \
+}
-#define mystmt_r(stmt,r) \
-if( r != 0) \
+#define mystmt_init_r(stmt) \
{ \
- mysterror(stmt,NULL); \
- myassert_r(true);\
-}
+myassert(stmt == 0);\
+}
#define mytest(x) if(!x) {myerror(NULL);myassert(true);}
#define mytest_r(x) if(x) {myerror(NULL);myassert(true);}
+#define PREPARE(A,B) mysql_prepare(A,B,strlen(B))
+
/********************************************************
* connect to the server *
*********************************************************/
static void client_connect()
{
+ char buff[255];
myheader("client_connect");
if(!(mysql = mysql_init(NULL)))
@@ -163,28 +181,37 @@ static void client_connect()
opt_password, opt_db ? opt_db:"test", opt_port,
opt_unix_socket, 0)))
{
- myerror("connection failed");
+ myerror("connection failed");
+ mysql_close(mysql);
exit(0);
}
/* set AUTOCOMMIT to ON*/
mysql_autocommit(mysql, true);
+ sprintf(buff,"CREATE DATABASE IF NOT EXISTS %s", current_db);
+ mysql_query(mysql, buff);
+ sprintf(buff,"USE %s", current_db);
+ mysql_query(mysql, buff);
}
/********************************************************
* close the connection *
*********************************************************/
-void client_disconnect()
+static void client_disconnect()
{
- myheader("client_disconnect");
-
- mysql_close(mysql);
+ if (mysql)
+ {
+ char buff[255];
+ sprintf(buff,"DROP DATABASE IF EXISTS %s", current_db);
+ mysql_query(mysql, buff);
+ mysql_close(mysql);
+ }
}
/********************************************************
* query processing *
*********************************************************/
-void client_query()
+static void client_query()
{
int rc;
@@ -222,7 +249,7 @@ void client_query()
/********************************************************
* print dashes *
*********************************************************/
-void my_print_dashes(MYSQL_RES *result)
+static void my_print_dashes(MYSQL_RES *result)
{
MYSQL_FIELD *field;
unsigned int i,j;
@@ -244,7 +271,7 @@ void my_print_dashes(MYSQL_RES *result)
/********************************************************
* print resultset metadata information *
*********************************************************/
-void my_print_result_metadata(MYSQL_RES *result)
+static void my_print_result_metadata(MYSQL_RES *result)
{
MYSQL_FIELD *field;
unsigned int i,j;
@@ -287,6 +314,9 @@ int my_process_result_set(MYSQL_RES *result)
MYSQL_FIELD *field;
unsigned int i;
unsigned int row_count=0;
+
+ if (!result)
+ return 0;
my_print_result_metadata(result);
@@ -313,50 +343,157 @@ int my_process_result_set(MYSQL_RES *result)
my_print_dashes(result);
if (mysql_errno(mysql) != 0)
- fprintf(stderr, "\n\tmysql_fetch_row() failed\n");
+ fprintf(stderr, "\n mysql_fetch_row() failed\n");
else
- fprintf(stdout,"\n\t%d rows returned\n", row_count);
+ fprintf(stdout,"\n %d rows returned", row_count);
return(row_count);
}
-static void verify_col_data(const char *table, const char *col, const char *exp_data)
+/********************************************************
+* process the stmt result set *
+*********************************************************/
+uint my_process_stmt_result(MYSQL_STMT *stmt)
{
- MYSQL_STMT *stmt;
- MYSQL_BIND bind[1];
- char data[255];
- int rc;
-
- init_bind(bind);
+ int field_count;
+ uint row_count= 0;
+ MYSQL_BIND buffer[50];
+ MYSQL_FIELD *field;
+ MYSQL_RES *result;
+ char data[50][255];
+ long length[50];
+ int rc, i;
+
+ if (!(result= mysql_prepare_result(stmt)))
+ {
+ while (!mysql_fetch(stmt));
+ return 0;
+ }
- bind[0].buffer_type=FIELD_TYPE_STRING;
- bind[0].buffer= (char *)data;
- bind[0].buffer_length= sizeof(data);
+ field_count= stmt->field_count;
+ for(i=0; i < field_count; i++)
+ {
+ buffer[i].buffer_type= MYSQL_TYPE_STRING;
+ buffer[i].buffer_length=50;
+ buffer[i].length=(long *)&length[i];
+ buffer[i].buffer=(gptr)data[i];
+ }
- sprintf(query, "SELECT `%s` FROM `%s`", col, table);
+ my_print_result_metadata(result);
- printf("\n %s", query);
- stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ rc= mysql_bind_result(stmt,buffer);
+ mystmt(stmt,rc);
- rc = mysql_bind_result(stmt,bind);
- mystmt(stmt, rc);
+ mysql_field_seek(result, 0);
+ while (mysql_fetch(stmt) == 0)
+ {
+ fputc('\t',stdout);
+ fputc('|',stdout);
- rc = mysql_execute(stmt);
- mystmt(stmt, rc);
+ for (i=0; i < field_count; i++)
+ {
+ field = mysql_fetch_field(result);
+ if(length[i] == MYSQL_NULL_DATA)
+ fprintf(stdout, " %-*s |", (int) field->max_length, "NULL");
+ else if (IS_NUM(field->type))
+ fprintf(stdout, " %*s |", (int) field->max_length, data[i]);
+ else
+ fprintf(stdout, " %-*s |", (int) field->max_length, data[i]);
+ }
+ fputc('\t',stdout);
+ fputc('\n',stdout);
+ row_count++;
+ }
+ my_print_dashes(result);
+ fprintf(stdout,"\n %d rows returned", row_count);
+ mysql_free_result(result);
- rc = mysql_fetch(stmt);
- mystmt(stmt,rc);
+ return row_count;
+}
- printf("\n data : %s (expected: %s)",data, exp_data);
- assert(strcmp(data,exp_data)==0);
+/*
+ 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);
- mysql_stmt_close(stmt);
+ fprintf(stdout,"\n %s", query);
+ rc = mysql_query(mysql, query);
+ myquery(rc);
+
+ field= 0;
+ }
+
+ result = mysql_use_result(mysql);
+ mytest(result);
+
+ if (!(row= mysql_fetch_row(result)) || !row[field])
+ {
+ fprintf(stdout,"\n *** ERROR: FAILED TO GET THE RESULT ***");
+ exit(1);
+ }
+ fprintf(stdout,"\n obtained: `%s` (expected: `%s`)",
+ row[field], exp_data);
+ myassert(strcmp(row[field],exp_data) == 0);
+ mysql_free_result(result);
+}
+
+/*
+ Utility function to verify the field members
+*/
+
+static void verify_prepare_field(MYSQL_RES *result,
+ unsigned int no,const char *name, const char *org_name,
+ enum enum_field_types type, const char *table,
+ const char *org_table, const char *db)
+{
+ MYSQL_FIELD *field;
+
+ if (!(field= mysql_fetch_field_direct(result,no)))
+ {
+ fprintf(stdout,"\n *** ERROR: FAILED TO GET THE RESULT ***");
+ exit(1);
+ }
+ fprintf(stdout,"\n field[%d]:", no);
+ fprintf(stdout,"\n name :`%s`\t(expected: `%s`)", field->name, name);
+ fprintf(stdout,"\n org_name :`%s`\t(expected: `%s`)", field->org_name, org_name);
+ fprintf(stdout,"\n type :`%d`\t(expected: `%d`)", field->type, type);
+ fprintf(stdout,"\n table :`%s`\t(expected: `%s`)", field->table, table);
+ fprintf(stdout,"\n org_table:`%s`\t(expected: `%s`)", field->org_table, org_table);
+ fprintf(stdout,"\n database :`%s`\t(expected: `%s`)", field->db, db);
+ fprintf(stdout,"\n");
+ myassert(strcmp(field->name,name) == 0);
+ myassert(strcmp(field->org_name,org_name) == 0);
+ myassert(field->type == type);
+ myassert(strcmp(field->table,table) == 0);
+ myassert(strcmp(field->org_table,org_table) == 0);
+ myassert(strcmp(field->db,db) == 0);
+}
+
+/*
+ Utility function to verify the parameter count
+*/
+static void verify_param_count(MYSQL_STMT *stmt, long exp_count)
+{
+ long param_count= mysql_param_count(stmt);
+ fprintf(stdout,"\n total parameters in stmt: %ld (expected: %ld)",
+ param_count, exp_count);
+ myassert(param_count == exp_count);
}
+
/********************************************************
* store result processing *
*********************************************************/
-void client_store_result()
+static void client_store_result()
{
MYSQL_RES *result;
int rc;
@@ -375,9 +512,9 @@ void client_store_result()
}
/********************************************************
-* use result processing *
+* fetch the results
*********************************************************/
-void client_use_result()
+static void client_use_result()
{
MYSQL_RES *result;
int rc;
@@ -398,7 +535,7 @@ void client_use_result()
/********************************************************
* query processing *
*********************************************************/
-void test_debug_example()
+static void test_debug_example()
{
int rc;
MYSQL_RES *result;
@@ -418,7 +555,7 @@ void test_debug_example()
rc = mysql_query(mysql,"UPDATE test_debug_example SET name='updated' WHERE name='deleted'");
myquery(rc);
- rc = mysql_query(mysql,"SELECT * FROM test_debug_example");
+ rc = mysql_query(mysql,"SELECT * FROM test_debug_example where name='mysql'");
myquery(rc);
result = mysql_use_result(mysql);
@@ -434,7 +571,7 @@ void test_debug_example()
/********************************************************
* to test autocommit feature *
*********************************************************/
-void test_tran_bdb()
+static void test_tran_bdb()
{
MYSQL_RES *result;
MYSQL_ROW row;
@@ -512,7 +649,7 @@ void test_tran_bdb()
/********************************************************
* to test autocommit feature *
*********************************************************/
-void test_tran_innodb()
+static void test_tran_innodb()
{
MYSQL_RES *result;
MYSQL_ROW row;
@@ -591,10 +728,10 @@ void test_tran_innodb()
To test simple prepares of all DML statements
*********************************************************/
-void test_prepare_simple()
+static void test_prepare_simple()
{
MYSQL_STMT *stmt;
- int rc,param_count;
+ int rc;
myheader("test_prepare_simple");
@@ -610,41 +747,33 @@ void test_prepare_simple()
/* alter table */
strcpy(query,"ALTER TABLE test_prepare_simple ADD new char(20)");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout,"\n total parameters in alter:%d\n", param_count);
- assert(param_count == 0);
+ verify_param_count(stmt,0);
mysql_stmt_close(stmt);
/* insert */
strcpy(query,"INSERT INTO test_prepare_simple VALUES(?,?)");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout,"\n total parameters in insert:%d\n", param_count);
- assert(param_count == 2);
+ verify_param_count(stmt,2);
mysql_stmt_close(stmt);
/* update */
strcpy(query,"UPDATE test_prepare_simple SET id=? WHERE id=? AND name= ?");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout,"\n total parameters in update:%d\n", param_count);
- assert(param_count == 3);
+ verify_param_count(stmt,3);
mysql_stmt_close(stmt);
/* delete */
strcpy(query,"DELETE FROM test_prepare_simple WHERE id=10");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout,"\n total parameters in delete:%d\n", param_count);
- assert(param_count == 0);
+ verify_param_count(stmt,0);
rc = mysql_execute(stmt);
mystmt(stmt, rc);
@@ -653,11 +782,9 @@ void test_prepare_simple()
/* delete */
strcpy(query,"DELETE FROM test_prepare_simple WHERE id=?");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout,"\n total parameters in delete:%d\n", param_count);
- assert(param_count == 1);
+ verify_param_count(stmt,1);
rc = mysql_execute(stmt);
mystmt_r(stmt, rc);
@@ -666,11 +793,9 @@ void test_prepare_simple()
/* select */
strcpy(query,"SELECT * FROM test_prepare_simple WHERE id=? AND name= ?");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout,"\n total parameters in select:%d\n", param_count);
- assert(param_count == 2);
+ verify_param_count(stmt,2);
mysql_stmt_close(stmt);
@@ -683,9 +808,10 @@ void test_prepare_simple()
/********************************************************
* to test simple prepare field results *
*********************************************************/
-void test_prepare_field_result()
+static void test_prepare_field_result()
{
MYSQL_STMT *stmt;
+ MYSQL_RES *result;
int rc,param_count;
myheader("test_prepare_field_result");
@@ -696,29 +822,47 @@ void test_prepare_field_result()
rc = mysql_commit(mysql);
myquery(rc);
- rc = mysql_query(mysql,"CREATE TABLE test_prepare_field_result(id int, name varchar(50), extra int)");
+ rc = mysql_query(mysql,"CREATE TABLE test_prepare_field_result(int_c int, \
+ var_c varchar(50), ts_c timestamp(14),\
+ char_c char(3), date_c date,extra tinyint)");
myquery(rc);
/* insert */
- strcpy(query,"SELECT id,name FROM test_prepare_field_result WHERE id=?");
+ strcpy(query,"SELECT int_c,var_c,date_c as date,ts_c,char_c FROM \
+ test_prepare_field_result as t1 WHERE int_c=?");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout,"\n total parameters in insert:%d\n", param_count);
- assert(param_count == 1);
- mysql_stmt_close(stmt);
+ verify_param_count(stmt,1);
- /* now fetch the results ..*/
- rc = mysql_commit(mysql);
- myquery(rc);
+ result = mysql_prepare_result(stmt);
+ mytest(result);
+
+ my_print_result_metadata(result);
+
+ fprintf(stdout,"\n\n field attributes:\n");
+ verify_prepare_field(result,0,"int_c","int_c",MYSQL_TYPE_LONG,
+ "t1","test_prepare_field_result",current_db);
+ verify_prepare_field(result,1,"var_c","var_c",MYSQL_TYPE_VAR_STRING,
+ "t1","test_prepare_field_result",current_db);
+ verify_prepare_field(result,2,"date","date_c",MYSQL_TYPE_DATE,
+ "t1","test_prepare_field_result",current_db);
+ verify_prepare_field(result,3,"ts_c","ts_c",MYSQL_TYPE_TIMESTAMP,
+ "t1","test_prepare_field_result",current_db);
+ verify_prepare_field(result,4,"char_c","char_c",MYSQL_TYPE_STRING,
+ "t1","test_prepare_field_result",current_db);
+
+ param_count= mysql_num_fields(result);
+ fprintf(stdout,"\n\n total fields: `%d` (expected: `5`)", param_count);
+ myassert(param_count == 5);
+ mysql_stmt_close(stmt);
}
/********************************************************
* to test simple prepare field results *
*********************************************************/
-void test_prepare_syntax()
+static void test_prepare_syntax()
{
MYSQL_STMT *stmt;
int rc;
@@ -736,11 +880,11 @@ void test_prepare_syntax()
strcpy(query,"INSERT INTO test_prepare_syntax VALUES(?");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery_r(stmt);
+ mystmt_init_r(stmt);
strcpy(query,"SELECT id,name FROM test_prepare_syntax WHERE id=? AND WHERE");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery_r(stmt);
+ mystmt_init_r(stmt);
/* now fetch the results ..*/
rc = mysql_commit(mysql);
@@ -751,10 +895,10 @@ void test_prepare_syntax()
/********************************************************
* to test simple prepare *
*********************************************************/
-void test_prepare()
+static void test_prepare()
{
MYSQL_STMT *stmt;
- int rc,param_count;
+ int rc;
char query[200];
int int_data;
char str_data[50];
@@ -779,7 +923,7 @@ void test_prepare()
myquery(rc);
rc = mysql_query(mysql,"CREATE TABLE my_prepare(col1 tinyint,\
- col2 varchar(50), col3 int,\
+ col2 varchar(15), col3 int,\
col4 smallint, col5 bigint, \
col6 float, col7 double )");
myquery(rc);
@@ -787,11 +931,9 @@ void test_prepare()
/* insert by prepare */
strcpy(query,"INSERT INTO my_prepare VALUES(?,?,?,?,?,?,?)");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout," total parameters in insert:%d\n", param_count);
- assert(param_count == 7);
+ verify_param_count(stmt,7);
/* tinyint */
bind[0].buffer_type=FIELD_TYPE_TINY;
@@ -852,7 +994,7 @@ void test_prepare()
result = mysql_store_result(mysql);
mytest(result);
- assert((int)tiny_data == my_process_result_set(result));
+ myassert((int)tiny_data == my_process_result_set(result));
mysql_free_result(result);
}
@@ -860,10 +1002,10 @@ void test_prepare()
/********************************************************
* to test double comparision *
*********************************************************/
-void test_double_compare()
+static void test_double_compare()
{
MYSQL_STMT *stmt;
- int rc,param_count;
+ int rc;
char query[200],real_data[10], tiny_data;
double double_data;
MYSQL_RES *result;
@@ -890,10 +1032,9 @@ void test_double_compare()
strcpy(query, "UPDATE test_double_compare SET col1=100 WHERE col1 = ? AND col2 = ? AND COL3 = ?");
stmt = mysql_prepare(mysql,query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout," total parameters in update:%d\n", param_count);
+ verify_param_count(stmt,3);
/* tinyint */
bind[0].buffer_type=FIELD_TYPE_TINY;
@@ -916,7 +1057,7 @@ void test_double_compare()
mystmt(stmt, rc);
rc = (int)mysql_affected_rows(mysql);
- printf("\n total affected rows:%d",rc);
+ fprintf(stdout,"\n total affected rows:%d",rc);
mysql_stmt_close(stmt);
@@ -932,21 +1073,17 @@ void test_double_compare()
result = mysql_store_result(mysql);
mytest(result);
- assert((int)tiny_data == my_process_result_set(result));
+ myassert((int)tiny_data == my_process_result_set(result));
mysql_free_result(result);
-
}
-
-
-
/********************************************************
* to test simple null *
*********************************************************/
-void test_null()
+static void test_null()
{
MYSQL_STMT *stmt;
- int rc,param_count;
+ int rc;
int nData=1;
MYSQL_RES *result;
MYSQL_BIND bind[2];
@@ -966,15 +1103,13 @@ void test_null()
/* insert by prepare, wrong column name */
strcpy(query,"INSERT INTO test_null(col3,col2) VALUES(?,?)");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery_r(stmt);
+ mystmt_init_r(stmt);
strcpy(query,"INSERT INTO test_null(col1,col2) VALUES(?,?)");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout," total parameters in insert:%d\n", param_count);
- assert(param_count == 2);
+ verify_param_count(stmt,2);
bind[0].is_null=1;
bind[0].buffer_type=MYSQL_TYPE_NULL;
@@ -1003,49 +1138,171 @@ void test_null()
result = mysql_store_result(mysql);
mytest(result);
- assert(nData == my_process_result_set(result));
+ myassert(nData == my_process_result_set(result));
mysql_free_result(result);
}
+/********************************************************
+* to test fetch null *
+*********************************************************/
+static void test_fetch_null()
+{
+ MYSQL_STMT *stmt;
+ int rc;
+ const char query[100];
+ int length[11], i, nData;
+ MYSQL_BIND bind[11];
+
+ myheader("test_fetch_null");
+
+ init_bind(bind);
+ rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_fetch_null");
+ myquery(rc);
+
+ rc = mysql_commit(mysql);
+ myquery(rc);
+
+ rc = mysql_query(mysql,"CREATE TABLE test_fetch_null(col1 tinyint, col2 smallint, \
+ col3 int, col4 bigint, \
+ col5 float, col6 double, \
+ col7 date, col8 time, \
+ col9 varbinary(10), \
+ col10 varchar(50),\
+ col11 char(20))");
+ myquery(rc);
+
+ rc = mysql_commit(mysql);
+ myquery(rc);
+
+ rc = mysql_query(mysql,"INSERT INTO test_fetch_null(col11) VALUES(1000)");
+ myquery(rc);
+
+ rc = mysql_commit(mysql);
+ myquery(rc);
+
+ /* fetch */
+ for (i=0; i < 10; i++)
+ {
+ bind[i].buffer_type=FIELD_TYPE_LONG;
+ length[i]=99;
+ bind[i].length= (long *)&length[i];
+ }
+ bind[i].buffer_type=FIELD_TYPE_LONG;
+ bind[i].buffer=(gptr)&nData;
+
+ strcpy((char *)query , "SELECT * FROM test_fetch_null");
+ stmt = mysql_prepare(mysql, query, strlen(query));
+ mystmt_init(stmt);
+
+ rc = mysql_bind_result(stmt,bind);
+ mystmt(stmt, rc);
+
+ rc = mysql_execute(stmt);
+ mystmt(stmt, rc);
+
+ rc = mysql_fetch(stmt);
+ mystmt(stmt,rc);
+
+ for (i=0; i < 10; i++)
+ {
+ fprintf(stdout, "\n data[%d]: %s", i, length[i] == MYSQL_NULL_DATA ? "NULL" : "NOT NULL");
+ myassert(length[i] == MYSQL_NULL_DATA);
+ }
+ fprintf(stdout, "\n data[%d]: %d", i, nData);
+ myassert(nData == 1000);
+
+ rc = mysql_fetch(stmt);
+ myassert(rc == MYSQL_NO_DATA);
+
+ mysql_stmt_close(stmt);
+}
/********************************************************
* to test simple select *
*********************************************************/
-void test_select_simple()
+static void test_select_version()
{
MYSQL_STMT *stmt;
- int rc,length;
+ int rc;
+ const char query[100];
+
+ myheader("test_select_version");
+
+ strcpy((char *)query , "SELECT @@version");
+ stmt = PREPARE(mysql, query);
+ mystmt_init(stmt);
+
+ verify_param_count(stmt,0);
+
+ rc = mysql_execute(stmt);
+ mystmt(stmt, rc);
+
+ my_process_stmt_result(stmt);
+ mysql_stmt_close(stmt);
+}
+
+/********************************************************
+* to test simple select *
+*********************************************************/
+static void test_select_simple()
+{
+ MYSQL_STMT *stmt;
+ int rc;
const char query[100];
- MYSQL_RES *result;
myheader("test_select_simple");
/* insert by prepare */
strcpy((char *)query, "SHOW TABLES FROM mysql");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- length = mysql_param_count(stmt);
- fprintf(stdout," total parameters in select:%d\n", length);
- assert(length == 0);
+ verify_param_count(stmt,0);
rc = mysql_execute(stmt);
mystmt(stmt, rc);
- /* get the result */
- result = mysql_store_result(mysql);
- mytest(result);
+ my_process_stmt_result(stmt);
+ mysql_stmt_close(stmt);
+}
- my_process_result_set(result);
- mysql_free_result(result);
+/********************************************************
+* to test simple select to debug *
+*********************************************************/
+static void test_select_direct()
+{
+ int rc;
+ MYSQL_RES *result;
- mysql_stmt_close(stmt);
+ myheader("test_select_direct");
+
+ rc = mysql_autocommit(mysql,true);
+ myquery(rc);
-#if 0
- strcpy((char *)query , "SELECT @@ VERSION");
- length = strlen(query);
- rc = mysql_query(mysql,query);
+ rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_select");
+ myquery(rc);
+
+ rc = mysql_commit(mysql);
+ myquery(rc);
+
+ rc = mysql_query(mysql,"CREATE TABLE test_select(id int, id1 tinyint, \
+ id2 float, \
+ id3 double, \
+ name varchar(50))");
+ myquery(rc);
+
+ rc = mysql_commit(mysql);
+ myquery(rc);
+
+ /* insert a row and commit the transaction */
+ rc = mysql_query(mysql,"INSERT INTO test_select VALUES(10,5,2.3,4.5,'venu')");
+ myquery(rc);
+
+ rc = mysql_commit(mysql);
+ myquery(rc);
+
+ rc = mysql_query(mysql,"SELECT * FROM test_select");
myquery(rc);
/* get the result */
@@ -1054,22 +1311,88 @@ void test_select_simple()
my_process_result_set(result);
mysql_free_result(result);
-#endif
}
+/********************************************************
+* to test simple select with prepare *
+*********************************************************/
+static void test_select_prepare()
+{
+ int rc, count;
+ MYSQL_STMT *stmt;
+
+ myheader("test_select_prepare");
+
+ rc = mysql_autocommit(mysql,true);
+ myquery(rc);
+
+ rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_select");
+ myquery(rc);
+
+ rc = mysql_commit(mysql);
+ myquery(rc);
+
+ rc = mysql_query(mysql,"CREATE TABLE test_select(id int, name varchar(50))");
+ myquery(rc);
+
+ rc = mysql_commit(mysql);
+ myquery(rc);
+
+ /* insert a row and commit the transaction */
+ rc = mysql_query(mysql,"INSERT INTO test_select VALUES(10,'venu')");
+ myquery(rc);
+
+ rc = mysql_commit(mysql);
+ myquery(rc);
+
+ stmt = mysql_prepare(mysql,"SELECT * FROM test_select",50);
+ mystmt_init(stmt);
+
+ rc = mysql_execute(stmt);
+ mystmt(stmt,rc);
+
+ count= my_process_stmt_result(stmt);
+
+ rc = mysql_query(mysql,"DROP TABLE test_select");
+ myquery(rc);
+
+ rc = mysql_commit(mysql);
+ myquery(rc);
+
+ rc = mysql_query(mysql,"CREATE TABLE test_select(id tinyint, id1 int, \
+ id2 float, id3 float, \
+ name varchar(50))");
+ myquery(rc);
+
+ rc = mysql_commit(mysql);
+ myquery(rc);
+
+ /* insert a row and commit the transaction */
+ rc = mysql_query(mysql,"INSERT INTO test_select(id,id1,id2,name) VALUES(10,5,2.3,'venu')");
+ myquery(rc);
+
+ rc = mysql_commit(mysql);
+ myquery(rc);
+
+ stmt = mysql_prepare(mysql,"SELECT * FROM test_select",25);
+ mystmt_init(stmt);
+
+ rc = mysql_execute(stmt);
+ mystmt(stmt,rc);
+
+ my_process_stmt_result(stmt);
+}
/********************************************************
* to test simple select *
*********************************************************/
-void test_select()
+static void test_select()
{
MYSQL_STMT *stmt;
- int rc,param_count=0;
- char *szData=(char *)"updated-value";
+ int rc;
+ char szData[25];
int nData=1;
MYSQL_BIND bind[2];
- MYSQL_RES *result;
-
myheader("test_select");
@@ -1105,15 +1428,13 @@ void test_select()
strcpy(query,"SELECT * FROM test_select WHERE id=? AND name=?");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout," total parameters in select:%d\n", param_count);
- assert(param_count == 2);
+ verify_param_count(stmt,2);
/* string data */
nData=10;
- szData=(char *)"venu";
+ strcpy(szData,(char *)"venu");
bind[1].buffer_type=FIELD_TYPE_STRING;
bind[1].buffer=szData;
bind[1].buffer_length=4;
@@ -1126,28 +1447,50 @@ void test_select()
rc = mysql_execute(stmt);
mystmt(stmt, rc);
+ myassert( 1 == my_process_stmt_result(stmt));
+
+ mysql_stmt_close(stmt);
+}
+
+/********************************************************
+* to test simple select show *
+*********************************************************/
+static void test_select_show()
+{
+ MYSQL_STMT *stmt;
+ int rc;
+ MYSQL_RES *result;
+
+ myheader("test_select_show");
+
+ mysql_autocommit(mysql,true);
+
+ strcpy(query,"SELECT * FROM mysql.host");
+ stmt = mysql_prepare(mysql, query, strlen(query));
+ mystmt_init(stmt);
+
+ verify_param_count(stmt,0);
+
+ rc = mysql_execute(stmt);
+ mystmt(stmt, rc);
+
/* get the result */
result = mysql_store_result(mysql);
mytest(result);
- assert( 1 == my_process_result_set(result));
+ my_process_result_set(result);
mysql_free_result(result);
mysql_stmt_close(stmt);
-
- /* bit complicated SELECT */
}
-
-
-
/********************************************************
* to test simple update *
*********************************************************/
-void test_simple_update()
+static void test_simple_update()
{
MYSQL_STMT *stmt;
- int rc,param_count;
+ int rc;
char szData[25];
int nData=1;
MYSQL_RES *result;
@@ -1175,7 +1518,7 @@ void test_simple_update()
rc = mysql_query(mysql,"INSERT INTO test_update VALUES(1,'MySQL',100)");
myquery(rc);
- assert(1 == mysql_affected_rows(mysql));
+ myassert(1 == mysql_affected_rows(mysql));
rc = mysql_commit(mysql);
myquery(rc);
@@ -1183,11 +1526,9 @@ void test_simple_update()
/* insert by prepare */
strcpy(query,"UPDATE test_update SET col2=? WHERE col1=?");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout," total parameters in update:%d\n", param_count);
- assert(param_count == 2);
+ verify_param_count(stmt,2);
nData=1;
bind[0].buffer_type=FIELD_TYPE_STRING;
@@ -1201,7 +1542,7 @@ void test_simple_update()
rc = mysql_execute(stmt);
mystmt(stmt, rc);
- assert(1 == mysql_affected_rows(mysql));
+ myassert(1 == mysql_affected_rows(mysql));
mysql_stmt_close(stmt);
@@ -1217,7 +1558,7 @@ void test_simple_update()
result = mysql_store_result(mysql);
mytest(result);
- assert(1 == my_process_result_set(result));
+ myassert(1 == my_process_result_set(result));
mysql_free_result(result);
}
@@ -1225,10 +1566,10 @@ void test_simple_update()
/********************************************************
* to test simple long data handling *
*********************************************************/
-void test_long_data()
+static void test_long_data()
{
MYSQL_STMT *stmt;
- int rc,param_count, int_data=10;
+ int rc, int_data;
char *data=NullS;
MYSQL_RES *result;
MYSQL_BIND bind[3];
@@ -1255,15 +1596,13 @@ void test_long_data()
strcpy(query,"INSERT INTO test_long_data(col1,col2) VALUES(?)");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery_r(stmt);
+ mystmt_init_r(stmt);
strcpy(query,"INSERT INTO test_long_data(col1,col2,col3) VALUES(?,?,?)");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout," total parameters in insert:%d\n", param_count);
- assert(param_count == 3);
+ verify_param_count(stmt,3);
bind[0].buffer=(char *)&int_data;
bind[0].buffer_type=FIELD_TYPE_LONG;
@@ -1272,7 +1611,7 @@ void test_long_data()
/* Non string or binary type, error */
bind[1].buffer_type=FIELD_TYPE_LONG;
rc = mysql_bind_param(stmt,bind);
- fprintf(stdout,"mysql_bind_param() returned %d\n",rc);
+ fprintf(stdout," mysql_bind_param() returned: %d\n",rc);
mystmt_r(stmt, rc);
bind[1].buffer_type=FIELD_TYPE_STRING;
@@ -1280,36 +1619,37 @@ void test_long_data()
rc = mysql_bind_param(stmt,bind);
mystmt(stmt, rc);
+ int_data= 999;
rc = mysql_execute(stmt);
- fprintf(stdout,"mysql_execute() returned %d\n",rc);
- assert(rc == MYSQL_NEED_DATA);
+ fprintf(stdout," mysql_execute() returned %d\n",rc);
+ myassert(rc == MYSQL_NEED_DATA);
data = (char *)"Micheal";
/* supply data in pieces */
- rc = mysql_send_long_data(stmt,1,data,7,1);
+ rc = mysql_send_long_data(stmt,1,data,7,0);
mystmt(stmt, rc);
/* try to execute mysql_execute() now, it should return
MYSQL_NEED_DATA as the long data supply is not yet over
*/
rc = mysql_execute(stmt);
- fprintf(stdout,"mysql_execute() returned %d\n",rc);
- assert(rc == MYSQL_NEED_DATA);
+ fprintf(stdout," mysql_execute() returned %d\n",rc);
+ myassert(rc == MYSQL_NEED_DATA);
/* append data again ..*/
/* Indicate end of data */
- data = (char *)" 'monty' widenius";
+ data = (char *)" 'monty' Widenius";
rc = mysql_send_long_data(stmt,1,data,17,1);
mystmt(stmt, rc);
- rc = mysql_send_long_data(stmt,2,"Venu (venu@mysql.com",4,1);
+ rc = mysql_send_long_data(stmt,2,"Venu (venu@mysql.com)",4,1);
mystmt(stmt, rc);
/* execute */
rc = mysql_execute(stmt);
- fprintf(stdout,"mysql_execute() returned %d\n",rc);
+ fprintf(stdout," mysql_execute() returned %d\n",rc);
mystmt(stmt,rc);
rc = mysql_commit(mysql);
@@ -1323,17 +1663,21 @@ void test_long_data()
result = mysql_store_result(mysql);
mytest(result);
- assert(1 == my_process_result_set(result));
+ myassert(1 == my_process_result_set(result));
mysql_free_result(result);
+
+ verify_col_data("test_long_data","col1","999");
+ verify_col_data("test_long_data","col2","Micheal 'monty' Widenius");
+ verify_col_data("test_long_data","col3","Venu");
}
/********************************************************
* to test long data (string) handling *
*********************************************************/
-void test_long_data_str()
+static void test_long_data_str()
{
MYSQL_STMT *stmt;
- int rc,param_count;
+ int rc, i;
char data[255];
long length;
MYSQL_RES *result;
@@ -1360,11 +1704,9 @@ void test_long_data_str()
strcpy(query,"INSERT INTO test_long_data_str VALUES(?,?)");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout," total parameters in insert:%d\n", param_count);
- assert(param_count == 2);
+ verify_param_count(stmt,2);
bind[0].buffer = (gptr)&length;
bind[0].buffer_type = FIELD_TYPE_LONG;
@@ -1377,28 +1719,24 @@ void test_long_data_str()
length = 10;
rc = mysql_execute(stmt);
- fprintf(stdout,"mysql_execute() returned %d\n",rc);
- assert(rc == MYSQL_NEED_DATA);
+ fprintf(stdout," mysql_execute() returned %d\n",rc);
+ myassert(rc == MYSQL_NEED_DATA);
length = 40;
sprintf(data,"MySQL AB");
/* supply data in pieces */
+ for(i=0; i < 4; i++)
{
- int i;
- for(i=0; i < 4; i++)
- {
- rc = mysql_send_long_data(stmt,1,(char *)data,5,0);
- mystmt(stmt, rc);
- }
-
- /* try to execute mysql_execute() now, it should return
- MYSQL_NEED_DATA as the long data supply is not yet over
- */
- rc = mysql_execute(stmt);
- fprintf(stdout,"mysql_execute() returned %d\n",rc);
- assert(rc == MYSQL_NEED_DATA);
+ rc = mysql_send_long_data(stmt,1,(char *)data,5,0);
+ mystmt(stmt, rc);
}
+ /* try to execute mysql_execute() now, it should return
+ MYSQL_NEED_DATA as the long data supply is not yet over
+ */
+ rc = mysql_execute(stmt);
+ fprintf(stdout," mysql_execute() returned %d\n",rc);
+ myassert(rc == MYSQL_NEED_DATA);
/* Indiate end of data supply */
rc = mysql_send_long_data(stmt,1,0,0,1);
@@ -1406,7 +1744,7 @@ void test_long_data_str()
/* execute */
rc = mysql_execute(stmt);
- fprintf(stdout,"mysql_execute() returned %d\n",rc);
+ fprintf(stdout," mysql_execute() returned %d\n",rc);
mystmt(stmt,rc);
mysql_stmt_close(stmt);
@@ -1422,20 +1760,27 @@ void test_long_data_str()
result = mysql_store_result(mysql);
mytest(result);
- assert(1 == my_process_result_set(result));
+ myassert(1 == my_process_result_set(result));
mysql_free_result(result);
+
+ sprintf(data,"%d", i*5);
+ verify_col_data("test_long_data_str","LENGTH(longstr)", data);
+ data[0]='\0';
+ while (i--)
+ sprintf(data,"%s%s", data,"MySQL");
+ verify_col_data("test_long_data_str","longstr", data);
}
/********************************************************
* to test long data (string) handling *
*********************************************************/
-void test_long_data_str1()
+static void test_long_data_str1()
{
MYSQL_STMT *stmt;
- int rc,param_count;
- char *data=(char *)"MySQL AB";
- int length;
+ int rc;
+ char data[255];
+ int length, i;
MYSQL_RES *result;
MYSQL_BIND bind[2];
@@ -1460,11 +1805,9 @@ void test_long_data_str1()
strcpy(query,"INSERT INTO test_long_data_str VALUES(?,?)");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout," total parameters in insert:%d\n", param_count);
- assert(param_count == 2);
+ verify_param_count(stmt,2);
bind[0].buffer=data; /* string data */
bind[0].is_long_data=1; /* specify long data suppy during run-time */
@@ -1478,44 +1821,41 @@ void test_long_data_str1()
length = 10;
rc = mysql_execute(stmt);
- fprintf(stdout,"mysql_execute() returned %d\n",rc);
- assert(rc == MYSQL_NEED_DATA);
+ fprintf(stdout," mysql_execute() returned %d\n",rc);
+ myassert(rc == MYSQL_NEED_DATA);
- length = strlen(data);
+ length = sprintf(data,"MySQL AB");
/* supply data in pieces */
+ for(i=0; i < 3; i++)
{
- int i;
- for(i=0; i < 2; i++)
- {
- rc = mysql_send_long_data(stmt,0,data,length,0);
- mystmt(stmt, rc);
+ rc = mysql_send_long_data(stmt,0,data,length,0);
+ mystmt(stmt, rc);
- rc = mysql_send_long_data(stmt,1,data,2,0);
- mystmt(stmt, rc);
- }
- /* try to execute mysql_execute() now, it should return
- MYSQL_NEED_DATA as the long data supply is not yet over
- */
- rc = mysql_execute(stmt);
- fprintf(stdout,"mysql_execute() returned %d\n",rc);
- assert(rc == MYSQL_NEED_DATA);
+ rc = mysql_send_long_data(stmt,1,data,2,0);
+ mystmt(stmt, rc);
}
-
+ /* try to execute mysql_execute() now, it should return
+ MYSQL_NEED_DATA as the long data supply is not yet over
+ */
+ rc = mysql_execute(stmt);
+ fprintf(stdout," mysql_execute() returned %d\n",rc);
+ myassert(rc == MYSQL_NEED_DATA);
+
/* Indiate end of data supply */
rc = mysql_send_long_data(stmt,1,0,0,1);
mystmt(stmt, rc);
rc = mysql_execute(stmt);
- fprintf(stdout,"mysql_execute() returned %d\n",rc);
- assert(rc == MYSQL_NEED_DATA);
+ fprintf(stdout," mysql_execute() returned %d\n",rc);
+ myassert(rc == MYSQL_NEED_DATA);
rc = mysql_send_long_data(stmt,0,0,0,1);
mystmt(stmt, rc);
/* execute */
rc = mysql_execute(stmt);
- fprintf(stdout,"mysql_execute() returned %d\n",rc);
+ fprintf(stdout," mysql_execute() returned %d\n",rc);
mystmt(stmt,rc);
mysql_stmt_close(stmt);
@@ -1531,18 +1871,24 @@ void test_long_data_str1()
result = mysql_store_result(mysql);
mytest(result);
- assert(1 == my_process_result_set(result));
+ myassert(1 == my_process_result_set(result));
mysql_free_result(result);
+
+ sprintf(data,"%d",i*length);
+ verify_col_data("test_long_data_str","length(longstr)",data);
+
+ sprintf(data,"%d",i*2);
+ verify_col_data("test_long_data_str","length(blb)",data);
}
/********************************************************
* to test long data (binary) handling *
*********************************************************/
-void test_long_data_bin()
+static void test_long_data_bin()
{
MYSQL_STMT *stmt;
- int rc,param_count;
+ int rc;
char data[255];
int length;
MYSQL_RES *result;
@@ -1569,11 +1915,9 @@ void test_long_data_bin()
strcpy(query,"INSERT INTO test_long_data_bin VALUES(?,?)");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout," total parameters in insert:%d\n", param_count);
- assert(param_count == 2);
+ verify_param_count(stmt,2);
bind[0].buffer = (gptr)&length;
bind[0].buffer_type = FIELD_TYPE_LONG;
@@ -1586,8 +1930,8 @@ void test_long_data_bin()
length = 10;
rc = mysql_execute(stmt);
- fprintf(stdout,"mysql_execute() returned %d\n",rc);
- assert(rc == MYSQL_NEED_DATA);
+ fprintf(stdout," mysql_execute() returned %d\n",rc);
+ myassert(rc == MYSQL_NEED_DATA);
sprintf(data,"MySQL AB");
@@ -1604,8 +1948,8 @@ void test_long_data_bin()
MYSQL_NEED_DATA as the long data supply is not yet over
*/
rc = mysql_execute(stmt);
- fprintf(stdout,"mysql_execute() returned %d\n",rc);
- assert(rc == MYSQL_NEED_DATA);
+ fprintf(stdout," mysql_execute() returned %d\n",rc);
+ myassert(rc == MYSQL_NEED_DATA);
}
/* Indiate end of data supply */
@@ -1614,7 +1958,7 @@ void test_long_data_bin()
/* execute */
rc = mysql_execute(stmt);
- fprintf(stdout,"mysql_execute() returned %d\n",rc);
+ fprintf(stdout," mysql_execute() returned %d\n",rc);
mystmt(stmt,rc);
mysql_stmt_close(stmt);
@@ -1630,7 +1974,7 @@ void test_long_data_bin()
result = mysql_store_result(mysql);
mytest(result);
- assert(1 == my_process_result_set(result));
+ myassert(1 == my_process_result_set(result));
mysql_free_result(result);
}
@@ -1638,10 +1982,10 @@ void test_long_data_bin()
/********************************************************
* to test simple delete *
*********************************************************/
-void test_simple_delete()
+static void test_simple_delete()
{
MYSQL_STMT *stmt;
- int rc,param_count;
+ int rc;
char szData[30]={0};
int nData=1;
MYSQL_RES *result;
@@ -1670,7 +2014,7 @@ void test_simple_delete()
rc = mysql_query(mysql,"INSERT INTO test_simple_delete VALUES(1,'MySQL',100)");
myquery(rc);
- assert(1 == mysql_affected_rows(mysql));
+ myassert(1 == mysql_affected_rows(mysql));
rc = mysql_commit(mysql);
myquery(rc);
@@ -1678,11 +2022,9 @@ void test_simple_delete()
/* insert by prepare */
strcpy(query,"DELETE FROM test_simple_delete WHERE col1=? AND col2=? AND col3=100");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout," total parameters in delete:%d\n", param_count);
- assert(param_count == 2);
+ verify_param_count(stmt,2);
nData=1;
strcpy(szData,"MySQL");
@@ -1697,7 +2039,7 @@ void test_simple_delete()
rc = mysql_execute(stmt);
mystmt(stmt, rc);
- assert(1 == mysql_affected_rows(mysql));
+ myassert(1 == mysql_affected_rows(mysql));
mysql_stmt_close(stmt);
@@ -1713,7 +2055,7 @@ void test_simple_delete()
result = mysql_store_result(mysql);
mytest(result);
- assert(0 == my_process_result_set(result));
+ myassert(0 == my_process_result_set(result));
mysql_free_result(result);
}
@@ -1722,10 +2064,10 @@ void test_simple_delete()
/********************************************************
* to test simple update *
*********************************************************/
-void test_update()
+static void test_update()
{
MYSQL_STMT *stmt;
- int rc,param_count;
+ int rc;
char szData[25];
int nData=1;
MYSQL_RES *result;
@@ -1753,11 +2095,9 @@ void test_update()
strcpy(query,"INSERT INTO test_update(col2,col3) VALUES(?,?)");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout," total parameters in insert:%d\n", param_count);
- assert(param_count == 2);
+ verify_param_count(stmt,2);
/* string data */
bind[0].buffer_type=FIELD_TYPE_STRING;
@@ -1773,16 +2113,14 @@ void test_update()
rc = mysql_execute(stmt);
mystmt(stmt, rc);
- assert(1 == mysql_affected_rows(mysql));
+ myassert(1 == mysql_affected_rows(mysql));
mysql_stmt_close(stmt);
strcpy(query,"UPDATE test_update SET col2=? WHERE col3=?");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout," total parameters in update:%d\n", param_count);
- assert(param_count == 2);
+ verify_param_count(stmt,2);
nData=100;
@@ -1797,7 +2135,7 @@ void test_update()
rc = mysql_execute(stmt);
mystmt(stmt, rc);
- assert(1 == mysql_affected_rows(mysql));
+ myassert(1 == mysql_affected_rows(mysql));
mysql_stmt_close(stmt);
@@ -1813,7 +2151,7 @@ void test_update()
result = mysql_store_result(mysql);
mytest(result);
- assert(1 == my_process_result_set(result));
+ myassert(1 == my_process_result_set(result));
mysql_free_result(result);
}
@@ -1821,13 +2159,13 @@ void test_update()
/********************************************************
* to test simple prepare *
*********************************************************/
-void test_init_prepare()
+static void test_prepare_noparam()
{
MYSQL_STMT *stmt;
- int param_count, rc;
+ int rc;
MYSQL_RES *result;
- myheader("test_init_prepare");
+ myheader("test_prepare_noparam");
rc = mysql_query(mysql,"DROP TABLE IF EXISTS my_prepare");
myquery(rc);
@@ -1842,11 +2180,9 @@ void test_init_prepare()
/* insert by prepare */
strcpy(query,"INSERT INTO my_prepare VALUES(10,'venu')");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout," total parameters in insert:%d\n", param_count);
- assert(param_count == 0);
+ verify_param_count(stmt,0);
rc = mysql_execute(stmt);
mystmt(stmt, rc);
@@ -1865,7 +2201,7 @@ void test_init_prepare()
result = mysql_store_result(mysql);
mytest(result);
- assert(1 == my_process_result_set(result));
+ myassert(1 == my_process_result_set(result));
mysql_free_result(result);
}
@@ -1873,12 +2209,12 @@ void test_init_prepare()
/********************************************************
* to test simple bind result *
*********************************************************/
-void test_bind_result()
+static void test_bind_result()
{
MYSQL_STMT *stmt;
int rc;
const char query[100];
- int nData;
+ int nData, length, length1;
char szData[100];
MYSQL_BIND bind[2];
@@ -1903,6 +2239,9 @@ void test_bind_result()
rc = mysql_query(mysql,"INSERT INTO test_bind_result VALUES(20,'MySQL')");
myquery(rc);
+ rc = mysql_query(mysql,"INSERT INTO test_bind_result(col2) VALUES('monty')");
+ myquery(rc);
+
rc = mysql_commit(mysql);
myquery(rc);
@@ -1910,13 +2249,131 @@ void test_bind_result()
bind[0].buffer_type=FIELD_TYPE_LONG;
bind[0].buffer= (gptr) &nData; /* integer data */
+ bind[0].length= (long *)&length;
bind[1].buffer_type=FIELD_TYPE_STRING;
bind[1].buffer=szData; /* string data */
bind[1].buffer_length=sizeof(szData);
+ bind[1].length=(long *)&length1;
+
+ strcpy((char *)query , "SELECT * FROM test_bind_result");
+ stmt = mysql_prepare(mysql, query, strlen(query));
+ 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 row 1: %d,%s(%d)",nData, szData, length1);
+ myassert(nData == 10);
+ myassert(strcmp(szData,"venu")==0);
+ myassert(length1 == 4);
+
+ rc = mysql_fetch(stmt);
+ mystmt(stmt,rc);
+
+ fprintf(stdout,"\n row 2: %d,%s(%d)",nData, szData, length1);
+ myassert(nData == 20);
+ myassert(strcmp(szData,"MySQL")==0);
+ myassert(length1 == 5);
+
+ length=99;
+ rc = mysql_fetch(stmt);
+ mystmt(stmt,rc);
+
+ if (length == MYSQL_NULL_DATA)
+ fprintf(stdout,"\n row 3: NULL,%s(%d)", szData, length1);
+ else
+ fprintf(stdout,"\n row 3: %d,%s(%d)", nData, szData, length1);
+ myassert(length == MYSQL_NULL_DATA);
+ myassert(strcmp(szData,"monty")==0);
+ myassert(length1 == 5);
+
+ rc = mysql_fetch(stmt);
+ myassert(rc == MYSQL_NO_DATA);
+
+ mysql_stmt_close(stmt);
+}
+
+
+/********************************************************
+* to test ext bind result *
+*********************************************************/
+static void test_bind_result_ext()
+{
+ MYSQL_STMT *stmt;
+ int rc;
+ const char query[100];
+ uchar t_data;
+ short s_data;
+ int i_data;
+ longlong b_data;
+ float f_data;
+ double d_data;
+ char szData[20], bData[20];
+ int szLength, bLength;
+ MYSQL_BIND bind[8];
+
+ myheader("test_bind_result_ext");
+
+ init_bind(bind);
+ rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_bind_result");
+ myquery(rc);
+
+ rc = mysql_commit(mysql);
+ myquery(rc);
+
+ rc = mysql_query(mysql,"CREATE TABLE test_bind_result(c1 tinyint, c2 smallint, \
+ c3 int, c4 bigint, \
+ c5 float, c6 double, \
+ c7 varbinary(10), \
+ c8 varchar(50))");
+ myquery(rc);
+
+ rc = mysql_commit(mysql);
+ myquery(rc);
+
+ rc = mysql_query(mysql,"INSERT INTO test_bind_result VALUES(19,2999,3999,4999999,\
+ 2345.6,5678.89563,\
+ 'venu','mysql')");
+ myquery(rc);
+
+ rc = mysql_commit(mysql);
+ myquery(rc);
+
+ bind[0].buffer_type=MYSQL_TYPE_TINY;
+ bind[0].buffer=(gptr)&t_data;
+
+ bind[1].buffer_type=MYSQL_TYPE_SHORT;
+ bind[2].buffer_type=MYSQL_TYPE_LONG;
+
+ bind[3].buffer_type=MYSQL_TYPE_LONGLONG;
+ bind[1].buffer=(gptr)&s_data;
+
+ bind[2].buffer=(gptr)&i_data;
+ bind[3].buffer=(gptr)&b_data;
+
+ bind[4].buffer_type=MYSQL_TYPE_FLOAT;
+ bind[4].buffer=(gptr)&f_data;
+
+ bind[5].buffer_type=MYSQL_TYPE_DOUBLE;
+ bind[5].buffer=(gptr)&d_data;
+
+ bind[6].buffer_type=MYSQL_TYPE_STRING;
+ bind[6].buffer=(gptr)&szData;
+ bind[6].length=(long *)&szLength;
+
+ bind[7].buffer_type=MYSQL_TYPE_TINY_BLOB;
+ bind[7].buffer=(gptr)&bData;
+ bind[7].length=(long *)&bLength;
strcpy((char *)query , "SELECT * FROM test_bind_result");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
rc = mysql_bind_result(stmt,bind);
mystmt(stmt, rc);
@@ -1927,30 +2384,281 @@ void test_bind_result()
rc = mysql_fetch(stmt);
mystmt(stmt,rc);
- printf("\n row 1:%d,%s",nData, szData);
- assert(nData == 10);
- assert(strcmp(szData,"venu")==0);
+ fprintf(stdout, "\n 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);
- printf("\n row 2:%d,%s",nData, szData);
- assert(nData == 20);
- assert(strcmp(szData,"MySQL")==0);
+ 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);
- assert(rc == MYSQL_NO_DATA);
+ 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 *
*********************************************************/
-void test_prepare_ext()
+static void test_prepare_ext()
{
MYSQL_STMT *stmt;
- int rc,param_count;
+ int rc;
char *sql;
int nData=1;
MYSQL_RES *result;
@@ -2012,9 +2720,7 @@ void test_prepare_ext()
stmt = mysql_prepare(mysql,query, strlen(query));
myquery(rc);
- param_count = mysql_param_count(stmt);
- fprintf(stdout," total parameters in insert:%d\n", param_count);
- assert(param_count == 6);
+ verify_param_count(stmt,6);
/*tinyint*/
bind_int[0].buffer_type=FIELD_TYPE_TINY;
@@ -2065,7 +2771,7 @@ void test_prepare_ext()
result = mysql_store_result(mysql);
mytest(result);
- assert(nData == my_process_result_set(result));
+ myassert(nData == my_process_result_set(result));
mysql_free_result(result);
}
@@ -2075,14 +2781,14 @@ void test_prepare_ext()
/********************************************************
* to test real and alias names *
*********************************************************/
-void test_field_names()
+static void test_field_names()
{
int rc;
MYSQL_RES *result;
myheader("test_field_names");
- printf("\n%d,%d,%d",MYSQL_TYPE_DECIMAL,MYSQL_TYPE_NEWDATE,MYSQL_TYPE_ENUM);
+ fprintf(stdout,"\n %d,%d,%d",MYSQL_TYPE_DECIMAL,MYSQL_TYPE_NEWDATE,MYSQL_TYPE_ENUM);
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_field_names1");
myquery(rc);
@@ -2108,7 +2814,7 @@ void test_field_names()
result = mysql_use_result(mysql);
mytest(result);
- assert(0 == my_process_result_set(result));
+ myassert(0 == my_process_result_set(result));
mysql_free_result(result);
/* with table name included with true column name */
@@ -2118,23 +2824,20 @@ void test_field_names()
result = mysql_use_result(mysql);
mytest(result);
- assert(0 == my_process_result_set(result));
+ myassert(0 == my_process_result_set(result));
mysql_free_result(result);
}
/********************************************************
* to test warnings *
*********************************************************/
-void test_warnings()
+static void test_warnings()
{
int rc;
MYSQL_RES *result;
myheader("test_warnings");
- rc = mysql_query(mysql,"USE test");
- myquery(rc);
-
rc = mysql_query(mysql,"SHOW WARNINGS");
myquery(rc);
@@ -2148,7 +2851,7 @@ void test_warnings()
/********************************************************
* to test errors *
*********************************************************/
-void test_errors()
+static void test_errors()
{
int rc;
MYSQL_RES *result;
@@ -2170,10 +2873,10 @@ void test_errors()
/********************************************************
* to test simple prepare-insert *
*********************************************************/
-void test_insert()
+static void test_insert()
{
MYSQL_STMT *stmt;
- int rc,param_count, length;
+ int rc, length;
char query[200];
char str_data[50];
char tiny_data;
@@ -2199,11 +2902,9 @@ void test_insert()
bzero(bind, sizeof(bind));
strcpy(query,"INSERT INTO test_prep_insert VALUES(?,?)");
stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout," total parameters in insert:%d\n", param_count);
- assert(param_count == 2);
+ verify_param_count(stmt,2);
/* tinyint */
bind[0].buffer_type=FIELD_TYPE_TINY;
@@ -2238,7 +2939,7 @@ void test_insert()
result = mysql_store_result(mysql);
mytest(result);
- assert((int)tiny_data == my_process_result_set(result));
+ myassert((int)tiny_data == my_process_result_set(result));
mysql_free_result(result);
}
@@ -2246,10 +2947,10 @@ void test_insert()
/********************************************************
* to test simple prepare-resultset info *
*********************************************************/
-void test_prepare_resultset()
+static void test_prepare_resultset()
{
MYSQL_STMT *stmt;
- int rc,param_count;
+ int rc;
char query[200];
MYSQL_RES *result;
@@ -2268,38 +2969,15 @@ void test_prepare_resultset()
name varchar(50),extra double)");
myquery(rc);
- /* insert by prepare */
- strcpy(query,"INSERT INTO test_prepare_resultset(id,name) VALUES(?,?)");
- stmt = mysql_prepare(mysql, query, strlen(query));
- myxquery(stmt);
+ strcpy(query,"SELECT * FROM test_prepare_resultset");
+ stmt = PREPARE(mysql, query);
+ mystmt_init(stmt);
- param_count = mysql_param_count(stmt);
- fprintf(stdout," total parameters in insert:%d\n", param_count);
- assert(param_count == 2);
+ verify_param_count(stmt,0);
- rc = mysql_query(mysql,"SELECT * FROM test_prepare_resultset");
- myquery(rc);
-
- /* get the prepared-result */
result = mysql_prepare_result(stmt);
- assert( result != 0);
-
- my_print_result_metadata(result);
- mysql_free_result(result);
-
- result = mysql_store_result(mysql);
mytest(result);
-
- assert(0 == my_process_result_set(result));
- mysql_free_result(result);
-
- /* get the prepared-result */
- result = mysql_prepare_result(stmt);
- assert( result != 0);
-
my_print_result_metadata(result);
- mysql_free_result(result);
-
mysql_stmt_close(stmt);
}
@@ -2307,7 +2985,7 @@ void test_prepare_resultset()
* to test field flags (verify .NET provider) *
*********************************************************/
-void test_field_flags()
+static void test_field_flags()
{
int rc;
MYSQL_RES *result;
@@ -2348,22 +3026,459 @@ void test_field_flags()
for(i=0; i< mysql_num_fields(result); i++)
{
field = mysql_fetch_field(result);
- printf("\nfield:%d",i);
+ fprintf(stdout,"\n field:%d",i);
if(field->flags & NOT_NULL_FLAG)
- printf("\n NOT_NULL_FLAG");
+ fprintf(stdout,"\n NOT_NULL_FLAG");
if(field->flags & PRI_KEY_FLAG)
- printf("\n PRI_KEY_FLAG");
+ fprintf(stdout,"\n PRI_KEY_FLAG");
if(field->flags & UNIQUE_KEY_FLAG)
- printf("\n UNIQUE_KEY_FLAG");
+ fprintf(stdout,"\n UNIQUE_KEY_FLAG");
if(field->flags & MULTIPLE_KEY_FLAG)
- printf("\n MULTIPLE_KEY_FLAG");
+ fprintf(stdout,"\n MULTIPLE_KEY_FLAG");
if(field->flags & AUTO_INCREMENT_FLAG)
- printf("\n AUTO_INCREMENT_FLAG");
+ fprintf(stdout,"\n AUTO_INCREMENT_FLAG");
}
mysql_free_result(result);
}
+/**************************************************************
+ * Test mysql_stmt_close for open stmts *
+**************************************************************/
+static void test_stmt_close()
+{
+ MYSQL *lmysql;
+ MYSQL_STMT *stmt1, *stmt2, *stmt3, *stmt_x;
+ MYSQL_BIND param[1];
+ MYSQL_RES *result;
+ char query[100];
+ unsigned int count;
+ int rc;
+
+ myheader("test_stmt_close");
+
+ init_bind(param);
+ if(!(lmysql = mysql_init(NULL)))
+ {
+ myerror("mysql_init() failed");
+ exit(0);
+ }
+ if (!(mysql_real_connect(lmysql,opt_host,opt_user,
+ opt_password, opt_db ? opt_db:"inter_client_test_db", opt_port,
+ opt_unix_socket, 0)))
+ {
+ myerror("connection failed");
+ exit(0);
+ }
+ if (opt_db)
+ strcpy(current_db,opt_db);
+
+ /* set AUTOCOMMIT to ON*/
+ mysql_autocommit(lmysql, true);
+ mysql_query(lmysql,"DROP TABLE IF EXISTS test_stmt_close");
+ mysql_query(lmysql,"CREATE TABLE test_stmt_close(id int)");
+
+ strcpy(query,"ALTER TABLE test_stmt_close ADD name varchar(20)");
+ stmt1= PREPARE(lmysql, query);
+ mystmt_init(stmt1);
+ count= mysql_param_count(stmt1);
+ fprintf(stdout,"\n total params in alter: %d", count);
+ myassert(count == 0);
+ strcpy(query,"INSERT INTO test_stmt_close(id) VALUES(?)");
+ stmt_x= PREPARE(mysql, query);
+ mystmt_init(stmt_x);
+ count= mysql_param_count(stmt_x);
+ fprintf(stdout,"\n total params in insert: %d", count);
+ myassert(count == 1);
+ strcpy(query,"UPDATE test_stmt_close SET id=? WHERE id=?");
+ stmt3= PREPARE(lmysql, query);
+ mystmt_init(stmt3);
+ count= mysql_param_count(stmt3);
+ fprintf(stdout,"\n total params in update: %d", count);
+ myassert(count == 2);
+ strcpy(query,"SELECT * FROM test_stmt_close WHERE id=?");
+ stmt2= PREPARE(lmysql, query);
+ mystmt_init(stmt2);
+ count= mysql_param_count(stmt2);
+ fprintf(stdout,"\n total params in select: %d", count);
+ myassert(count == 1);
+
+ rc= mysql_stmt_close(stmt1);
+ fprintf(stdout,"\n mysql_close_stmt(1) returned: %d", rc);
+ myassert(rc == 0);
+ mysql_close(lmysql); /* it should free all stmts */
+#if NOT_VALID
+ rc= mysql_stmt_close(stmt3);
+ fprintf(stdout,"\n mysql_close_stmt(3) returned: %d", rc);
+ myassert( rc == 1);
+ rc= mysql_stmt_close(stmt2);
+ fprintf(stdout,"\n mysql_close_stmt(2) returned: %d", rc);
+ myassert( rc == 1);
+#endif
+
+ count= 100;
+ param[0].buffer=(gptr)&count;
+ param[0].buffer_type=MYSQL_TYPE_LONG;
+ rc = mysql_bind_param(stmt_x, param);
+ mystmt(stmt_x, rc);
+ rc = mysql_execute(stmt_x);
+ mystmt(stmt_x, rc);
+
+ rc= (ulong)mysql_affected_rows(stmt_x->mysql);
+ fprintf(stdout,"\n total rows affected: %d", rc);
+ myassert (rc == 1);
+
+ rc= mysql_stmt_close(stmt_x);
+ fprintf(stdout,"\n mysql_close_stmt(x) returned: %d", rc);
+ myassert( rc == 0);
+
+ /*verify_col_data("test_stmt_close", "id", "100");*/
+ rc = mysql_query(mysql,"SELECT id FROM test_stmt_close");
+ myquery(rc);
+
+ result = mysql_store_result(mysql);
+ mytest(result);
+
+ myassert(1 == my_process_result_set(result));
+ mysql_free_result(result);
+}
+
+/********************************************************
+ * To test simple set-variable prepare *
+*********************************************************/
+static void test_set_variable()
+{
+ MYSQL_STMT *stmt;
+ int rc, select_limit=88;
+ char query[200];
+ MYSQL_BIND bind[1];
+ MYSQL_RES *result;
+
+
+ myheader("test_set_variable");
+
+ rc = mysql_autocommit(mysql, true);
+ myquery(rc);
+
+ strcpy(query,"SET GLOBAL delayed_insert_limit=?");
+ stmt = mysql_prepare(mysql, query, strlen(query));
+ mystmt_init(stmt);
+
+ verify_param_count(stmt,1);
+
+ result= mysql_param_result(stmt);
+ mytest_r(result);
+
+ init_bind(bind);
+
+ bind[0].buffer_type= MYSQL_TYPE_LONG;
+ bind[0].buffer=(gptr)&select_limit;
+
+ rc = mysql_bind_param(stmt, bind);
+ mystmt(stmt,rc);
+
+ rc= mysql_execute(stmt);
+ mystmt(stmt,rc);
+
+ mysql_store_result(mysql);
+
+ strcpy(query,"show variables like 'delayed_insert_limit'");
+ rc = mysql_query(mysql,query);
+ myquery(rc);
+
+ verify_col_data(NullS, NullS, "88");
+
+#if TO_BE_FIXED
+
+ select_limit= 100;/* reset to default */
+ rc= mysql_execute(stmt);
+ mystmt(stmt,rc);
+
+ mysql_store_result(mysql);
+ mysql_stmt_close(stmt);
+
+ rc = mysql_query(mysql,query);
+ myquery(rc);
+
+ verify_col_data(NullS, NullS, "100");
+#endif
+ mysql_stmt_close(stmt);
+}
+#if NOT_USED
+/* Insert meta info .. */
+static void test_insert_meta()
+{
+ MYSQL_STMT *stmt;
+ int rc;
+ char query[200];
+ MYSQL_RES *result;
+ MYSQL_FIELD *field;
+
+ myheader("test_insert_meta");
+
+ rc = mysql_autocommit(mysql, true);
+ myquery(rc);
+
+ rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_prep_insert");
+ myquery(rc);
+
+ rc = mysql_commit(mysql);
+ myquery(rc);
+
+ rc = mysql_query(mysql,"CREATE TABLE test_prep_insert(col1 tinyint,\
+ col2 varchar(50), col3 varchar(30))");
+ myquery(rc);
+
+ strcpy(query,"INSERT INTO test_prep_insert VALUES(10,'venu1','test')");
+ stmt = mysql_prepare(mysql, query, strlen(query));
+ mystmt_init(stmt);
+
+ verify_param_count(stmt,0);
+
+ result= mysql_param_result(stmt);
+ mytest_r(result);
+
+ strcpy(query,"INSERT INTO test_prep_insert VALUES(?,'venu',?)");
+ stmt = mysql_prepare(mysql, query, strlen(query));
+ mystmt_init(stmt);
+
+ verify_param_count(stmt,2);
+
+ result= mysql_param_result(stmt);
+ mytest(result);
+
+ my_print_result_metadata(result);
+
+ mysql_field_seek(result, 0);
+ field= mysql_fetch_field(result);
+ mytest(field);
+ fprintf(stdout, "\n obtained: `%s` (expected: `%s`)", field->name, "col1");
+ myassert(strcmp(field->name,"col1")==0);
+
+ field= mysql_fetch_field(result);
+ mytest(field);
+ fprintf(stdout, "\n obtained: `%s` (expected: `%s`)", field->name, "col3");
+ myassert(strcmp(field->name,"col3")==0);
+
+ field= mysql_fetch_field(result);
+ mytest_r(field);
+
+ mysql_free_result(result);
+ mysql_stmt_close(stmt);
+}
+
+/* Update meta info .. */
+static void test_update_meta()
+{
+ MYSQL_STMT *stmt;
+ int rc;
+ char query[200];
+ MYSQL_RES *result;
+ MYSQL_FIELD *field;
+
+ myheader("test_update_meta");
+
+ rc = mysql_autocommit(mysql, true);
+ myquery(rc);
+
+ rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_prep_update");
+ myquery(rc);
+
+ rc = mysql_commit(mysql);
+ myquery(rc);
+
+ rc = mysql_query(mysql,"CREATE TABLE test_prep_update(col1 tinyint,\
+ col2 varchar(50), col3 varchar(30))");
+ myquery(rc);
+
+ strcpy(query,"UPDATE test_prep_update SET col1=10, col2='venu1' WHERE col3='test'");
+ stmt = mysql_prepare(mysql, query, strlen(query));
+ mystmt_init(stmt);
+
+ verify_param_count(stmt,0);
+
+ result= mysql_param_result(stmt);
+ mytest_r(result);
+
+ strcpy(query,"UPDATE test_prep_update SET col1=?, col2='venu' WHERE col3=?");
+ stmt = mysql_prepare(mysql, query, strlen(query));
+ mystmt_init(stmt);
+
+ verify_param_count(stmt,2);
+
+ result= mysql_param_result(stmt);
+ mytest(result);
+
+ my_print_result_metadata(result);
+
+ mysql_field_seek(result, 0);
+ field= mysql_fetch_field(result);
+ mytest(field);
+ fprintf(stdout, "\n col obtained: `%s` (expected: `%s`)", field->name, "col1");
+ fprintf(stdout, "\n tab obtained: `%s` (expected: `%s`)", field->table, "test_prep_update");
+ myassert(strcmp(field->name,"col1")==0);
+ myassert(strcmp(field->table,"test_prep_update")==0);
+
+ field= mysql_fetch_field(result);
+ mytest(field);
+ fprintf(stdout, "\n col obtained: `%s` (expected: `%s`)", field->name, "col3");
+ fprintf(stdout, "\n tab obtained: `%s` (expected: `%s`)", field->table, "test_prep_update");
+ myassert(strcmp(field->name,"col3")==0);
+ myassert(strcmp(field->table,"test_prep_update")==0);
+
+ field= mysql_fetch_field(result);
+ mytest_r(field);
+
+ mysql_free_result(result);
+ mysql_stmt_close(stmt);
+}
+
+/* Select meta info .. */
+static void test_select_meta()
+{
+ MYSQL_STMT *stmt;
+ int rc;
+ char query[200];
+ MYSQL_RES *result;
+ MYSQL_FIELD *field;
+
+ myheader("test_select_meta");
+
+ rc = mysql_autocommit(mysql, true);
+ myquery(rc);
+
+ rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_prep_select");
+ myquery(rc);
+
+ rc = mysql_commit(mysql);
+ myquery(rc);
+
+ rc = mysql_query(mysql,"CREATE TABLE test_prep_select(col1 tinyint,\
+ col2 varchar(50), col3 varchar(30))");
+ myquery(rc);
+
+ strcpy(query,"SELECT * FROM test_prep_select WHERE col1=10");
+ stmt = mysql_prepare(mysql, query, strlen(query));
+ mystmt_init(stmt);
+
+ verify_param_count(stmt,0);
+
+ result= mysql_param_result(stmt);
+ mytest_r(result);
+
+ strcpy(query,"SELECT col1, col3 from test_prep_select WHERE col1=? AND col3='test' AND col2= ?");
+ stmt = mysql_prepare(mysql, query, strlen(query));
+ mystmt_init(stmt);
+
+ verify_param_count(stmt,2);
+
+ result= mysql_param_result(stmt);
+ mytest(result);
+
+ my_print_result_metadata(result);
+
+ mysql_field_seek(result, 0);
+ field= mysql_fetch_field(result);
+ mytest(field);
+ fprintf(stdout, "\n col obtained: `%s` (expected: `%s`)", field->name, "col1");
+ fprintf(stdout, "\n tab obtained: `%s` (expected: `%s`)", field->table, "test_prep_select");
+ myassert(strcmp(field->name,"col1")==0);
+ myassert(strcmp(field->table,"test_prep_select")==0);
+
+ field= mysql_fetch_field(result);
+ mytest(field);
+ fprintf(stdout, "\n col obtained: `%s` (expected: `%s`)", field->name, "col2");
+ fprintf(stdout, "\n tab obtained: `%s` (expected: `%s`)", field->table, "test_prep_select");
+ myassert(strcmp(field->name,"col2")==0);
+ myassert(strcmp(field->table,"test_prep_select")==0);
+
+ field= mysql_fetch_field(result);
+ mytest_r(field);
+
+ mysql_free_result(result);
+ mysql_stmt_close(stmt);
+}
+#endif
+
+/* Test FUNCTION field info / DATE_FORMAT() table_name . */
+static void test_func_fields()
+{
+ int rc;
+ MYSQL_RES *result;
+ MYSQL_FIELD *field;
+
+ myheader("test_func_fields");
+
+ rc = mysql_autocommit(mysql, true);
+ myquery(rc);
+
+ rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_dateformat");
+ myquery(rc);
+
+ rc = mysql_commit(mysql);
+ myquery(rc);
+
+ rc = mysql_query(mysql,"CREATE TABLE test_dateformat(id int, \
+ ts timestamp)");
+ myquery(rc);
+
+ rc = mysql_query(mysql, "INSERT INTO test_dateformat(id) values(10)");
+ myquery(rc);
+
+ rc = mysql_query(mysql, "SELECT ts FROM test_dateformat");
+ myquery(rc);
+
+ result = mysql_store_result(mysql);
+ mytest(result);
+
+ field = mysql_fetch_field(result);
+ mytest(field);
+ fprintf(stdout,"\n table name: `%s` (expected: `%s`)", field->table,
+ "test_dateformat");
+ myassert(strcmp(field->table, "test_dateformat")==0);
+
+ field = mysql_fetch_field(result);
+ mytest_r(field); /* no more fields */
+
+ mysql_free_result(result);
+
+ /* DATE_FORMAT */
+ rc = mysql_query(mysql, "SELECT DATE_FORMAT(ts,'%Y') AS 'venu' FROM test_dateformat");
+ myquery(rc);
+
+ result = mysql_store_result(mysql);
+ mytest(result);
+
+ field = mysql_fetch_field(result);
+ mytest(field);
+ fprintf(stdout,"\n table name: `%s` (expected: `%s`)", field->table, "");
+ myassert(field->table[0] == '\0');
+
+ field = mysql_fetch_field(result);
+ mytest_r(field); /* no more fields */
+
+ mysql_free_result(result);
+
+ /* FIELD ALIAS TEST */
+ rc = mysql_query(mysql, "SELECT DATE_FORMAT(ts,'%Y') AS 'YEAR' FROM test_dateformat");
+ myquery(rc);
+
+ result = mysql_store_result(mysql);
+ mytest(result);
+
+ field = mysql_fetch_field(result);
+ mytest(field);
+ fprintf(stdout,"\n field name: `%s` (expected: `%s`)", field->name, "YEAR");
+ fprintf(stdout,"\n field org name: `%s` (expected: `%s`)",field->org_name,"");
+ myassert(strcmp(field->name, "YEAR")==0);
+ myassert(field->org_name[0] == '\0');
+
+ field = mysql_fetch_field(result);
+ mytest_r(field); /* no more fields */
+
+ mysql_free_result(result);
+}
+
static struct my_option myctest_long_options[] =
{
{"help", '?', "Display this help and exit", 0, 0, 0, GET_NO_ARG, NO_ARG, 0,
@@ -2398,24 +3513,24 @@ static void usage(void)
puts("and you are welcome to modify and redistribute it under the GPL license\n");
puts(" Copyright (C) 1995-2002 MySQL AB ");
puts("-----------------------------------------------------------------------\n");
- printf("usage: %s [OPTIONS]\n\n", my_progname);
- printf("\
+ fprintf(stdout,"usage: %s [OPTIONS]\n\n", my_progname);
+ fprintf(stdout,"\
-?, --help Display this help message and exit.\n\
-D --database=... Database name to be used for test.\n\
-h, --host=... Connect to host.\n\
-p, --password[=...] Password to use when connecting to server.\n");
#ifdef __WIN__
- printf("\
+ fprintf(stdout,"\
-W, --pipe Use named pipes to connect to server.\n");
#endif
- printf("\
+ fprintf(stdout,"\
-P, --port=... Port number to use for connection.\n\
-S, --socket=... Socket file to use for connection.\n");
#ifndef DONT_ALLOW_USER_CHANGE
- printf("\
+ fprintf(stdout,"\
-u, --user=# User for login if not current user.\n");
#endif
- printf("*********************************************************************\n");
+ fprintf(stdout,"*********************************************************************\n");
}
static my_bool
@@ -2471,24 +3586,52 @@ int main(int argc, char **argv)
MY_INIT(argv[0]);
get_options(argc,argv);
- client_connect(); /* connect to server */
-
+ client_connect(); /* connect to server */
+ test_select_prepare();
+ test_prepare();
+ test_prepare_simple();
+ test_bind_result(); /* result bind test */
+ test_fetch_null(); /* to fetch null data */
+ test_fetch_date();
+ test_bind_result_ext(); /* result bind test - extension */
+ test_bind_result_ext1(); /* result bind test - extension */
+ test_select_direct(); /* direct select - protocol_simple debug */
+ test_select_prepare(); /* prepare select - protocol_prep debug */
+ test_select_direct(); /* direct select - protocol_simple debug */
+ test_select();
+ test_select_version();
+ test_set_variable(); /* set variable prepare */
+#if NOT_USED
+ test_select_meta(); /* select param meta information */
+ test_update_meta(); /* update param meta information */
+ test_insert_meta(); /* insert param meta information */
+#endif
+ test_simple_update(); /* simple update test */
+ test_func_fields();
+ test_long_data();
+ test_insert();
+ test_set_variable();
+ test_tran_innodb();
+ test_select_version();
+ test_select_simple();
+ test_debug_example();
+ test_select();
+ test_select_show();
test_null(); /* test null data handling */
- test_simple_update();
- //test_select_simple();
- //test_prepare_resultset();
- //test_select(); /* simple prepare-select */
+ test_simple_update();
+ test_prepare_resultset();
+ test_prepare_noparam();/* prepare without parameters */
+ test_select(); /* simple prepare-select */
test_insert(); /* prepare with insert */
- //test_bind_result(); /* result bind test */
- //test_long_data(); /* long data handling in pieces */
+ test_bind_result(); /* result bind test */
+ test_long_data(); /* long data handling in pieces */
test_prepare_simple();/* simple prepare */
test_prepare(); /* prepare test */
- test_prepare_simple();/* simple prepare */
test_null(); /* test null data handling */
test_debug_example(); /* some debugging case */
test_update(); /* prepare-update test */
test_simple_update(); /* simple prepare with update */
- //test_long_data(); /* long data handling in pieces */
+ test_long_data(); /* long data handling in pieces */
test_simple_delete(); /* prepare with delete */
test_field_names(); /* test for field names */
test_double_compare();/* float comparision */
@@ -2499,20 +3642,23 @@ int main(int argc, char **argv)
test_tran_innodb(); /* transaction test on InnoDB table type */
test_prepare_ext(); /* test prepare with all types conversion -- TODO */
test_prepare_syntax();/* syntax check for prepares */
- //test_prepare_field_result(); /* prepare meta info */
+ test_prepare_field_result(); /* prepare meta info */
+ test_prepare_resultset();
test_field_names(); /* test for field names */
test_field_flags(); /* test to help .NET provider team */
- //test_long_data_str(); /* long data handling */
- //test_long_data_str1();/* yet another long data handling */
- //test_long_data_bin(); /* long binary insertion */
+ test_long_data_str(); /* long data handling */
+ test_long_data_str1();/* yet another long data handling */
+ test_long_data_bin(); /* long binary insertion */
test_warnings(); /* show warnings test */
test_errors(); /* show errors test */
- //test_select_simple(); /* simple select prepare */
- //test_prepare_resultset();/* prepare meta info test */
-
+ test_select_simple(); /* simple select prepare */
+ test_prepare_resultset();/* prepare meta info test */
+ test_func_fields(); /* FUNCTION field info */
+ /*test_stmt_close(); */ /* mysql_stmt_close() test -- hangs */
+ test_prepare_field_result(); /* prepare meta info */
client_disconnect(); /* disconnect from server */
-
- fprintf(stdout,"\ndone !!!\n");
+
+ fprintf(stdout,"\n\nSUCCESS !!!\n");
return(0);
}
View Lorry Controller Status