mirror of
https://github.com/MariaDB/server.git
synced 2025-01-16 20:12:31 +01:00
84d0efec5e
Modification to new API test sql_prepare.cc: Fix for lock_types sql/sql_prepare.cc: Fix for lock_types tests/client_test.c: Modification to new API test
2518 lines
64 KiB
C
2518 lines
64 KiB
C
/***************************************************************************
|
|
client_test.c - description
|
|
-------------------------
|
|
begin : Sun Feb 3 2002
|
|
copyright : (C) MySQL AB 1995-2002, www.mysql.com
|
|
author : venu ( venu@mysql.com )
|
|
***************************************************************************/
|
|
|
|
/***************************************************************************
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
/***************************************************************************
|
|
* *
|
|
* This is a test sample to test the new features in MySQL client-server *
|
|
* protocol *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
#include <my_global.h>
|
|
|
|
#if defined(__WIN__) || defined(_WIN32) || defined(_WIN64)
|
|
#include <windows.h>
|
|
#endif
|
|
|
|
/* standrad headers */
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include <assert.h>
|
|
|
|
|
|
/* mysql client headers */
|
|
#include <my_sys.h>
|
|
#include <mysql.h>
|
|
#include <my_getopt.h>
|
|
|
|
#ifndef true
|
|
#define true 1
|
|
#endif
|
|
|
|
#ifndef false
|
|
#define false 0
|
|
#endif
|
|
|
|
#ifndef bzero
|
|
#define bzero(A,B) memset(A,0,B)
|
|
#endif
|
|
|
|
/* set default options */
|
|
static char *opt_db=0;
|
|
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 my_bool tty_password=0;
|
|
|
|
static MYSQL *mysql=0;
|
|
static char query[255];
|
|
|
|
#define myheader(str) { printf("\n\n#######################\n"); \
|
|
printf("%s",str); \
|
|
printf("\n#######################\n"); \
|
|
}
|
|
|
|
#define init_bind(x) (bzero(x,sizeof(x)))
|
|
|
|
void print_error(const char *msg)
|
|
{
|
|
if (mysql)
|
|
{
|
|
fprintf(stderr,"\n [MySQL]%s \n",mysql_error(mysql));
|
|
}
|
|
else if(msg) fprintf(stderr, "%s\n", msg);
|
|
}
|
|
|
|
void print_st_error(MYSQL_STMT *stmt, const char *msg)
|
|
{
|
|
if (stmt)
|
|
{
|
|
fprintf(stderr,"\n [MySQL]%s \n",mysql_stmt_error(stmt));
|
|
}
|
|
else if(msg) fprintf(stderr, "%s\n", msg);
|
|
}
|
|
|
|
#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_r(x) if(!x) {\
|
|
fprintf(stderr,"ASSERTION FAILED AT %d@%s\n",__LINE__, __FILE__);\
|
|
exit(1);\
|
|
}
|
|
|
|
#define myquery(r) \
|
|
if( r != 0) \
|
|
{ \
|
|
myerror(NULL); \
|
|
myassert(true);\
|
|
}
|
|
|
|
#define myquery_r(r) \
|
|
if( r != 0) \
|
|
{ \
|
|
myerror(NULL); \
|
|
myassert_r(true);\
|
|
}
|
|
|
|
#define mystmt(stmt,r) \
|
|
if( r != 0) \
|
|
{ \
|
|
mysterror(stmt,NULL); \
|
|
myassert(true);\
|
|
}
|
|
|
|
#define myxquery(stmt) \
|
|
if( stmt == 0) \
|
|
{ \
|
|
myerror(NULL); \
|
|
myassert(true);\
|
|
}
|
|
|
|
#define myxquery_r(stmt) \
|
|
if( stmt == 0) \
|
|
{ \
|
|
myerror(NULL); \
|
|
myassert_r(true);\
|
|
} \
|
|
else myassert(true);
|
|
|
|
#define mystmt_r(stmt,r) \
|
|
if( r != 0) \
|
|
{ \
|
|
mysterror(stmt,NULL); \
|
|
myassert_r(true);\
|
|
}
|
|
|
|
#define mytest(x) if(!x) {myerror(NULL);myassert(true);}
|
|
#define mytest_r(x) if(x) {myerror(NULL);myassert(true);}
|
|
|
|
/********************************************************
|
|
* connect to the server *
|
|
*********************************************************/
|
|
static void client_connect()
|
|
{
|
|
myheader("client_connect");
|
|
|
|
if(!(mysql = mysql_init(NULL)))
|
|
{
|
|
myerror("mysql_init() failed");
|
|
exit(0);
|
|
}
|
|
if (!(mysql_real_connect(mysql,opt_host,opt_user,
|
|
opt_password, opt_db ? opt_db:"test", opt_port,
|
|
opt_unix_socket, 0)))
|
|
{
|
|
myerror("connection failed");
|
|
exit(0);
|
|
}
|
|
|
|
/* set AUTOCOMMIT to ON*/
|
|
mysql_autocommit(mysql, true);
|
|
}
|
|
|
|
/********************************************************
|
|
* close the connection *
|
|
*********************************************************/
|
|
void client_disconnect()
|
|
{
|
|
myheader("client_disconnect");
|
|
|
|
mysql_close(mysql);
|
|
}
|
|
|
|
/********************************************************
|
|
* query processing *
|
|
*********************************************************/
|
|
void client_query()
|
|
{
|
|
int rc;
|
|
|
|
myheader("client_query");
|
|
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS myclient_test");
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"CREATE TABLE myclient_test(id int primary key auto_increment,\
|
|
name varchar(20))");
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"CREATE TABLE myclient_test(id int, name varchar(20))");
|
|
myquery_r(rc);
|
|
|
|
rc = mysql_query(mysql,"INSERT INTO myclient_test(name) VALUES('mysql')");
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"INSERT INTO myclient_test(name) VALUES('monty')");
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"INSERT INTO myclient_test(name) VALUES('venu')");
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"INSERT INTO myclient_test(name) VALUES('deleted')");
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"UPDATE myclient_test SET name='updated' WHERE name='deleted'");
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"UPDATE myclient_test SET id=3 WHERE name='updated'");
|
|
myquery_r(rc);
|
|
}
|
|
|
|
/********************************************************
|
|
* print dashes *
|
|
*********************************************************/
|
|
void my_print_dashes(MYSQL_RES *result)
|
|
{
|
|
MYSQL_FIELD *field;
|
|
unsigned int i,j;
|
|
|
|
mysql_field_seek(result,0);
|
|
fputc('\t',stdout);
|
|
fputc('+', stdout);
|
|
|
|
for(i=0; i< mysql_num_fields(result); i++)
|
|
{
|
|
field = mysql_fetch_field(result);
|
|
for(j=0; j < field->max_length+2; j++)
|
|
fputc('-',stdout);
|
|
fputc('+',stdout);
|
|
}
|
|
fputc('\n',stdout);
|
|
}
|
|
|
|
/********************************************************
|
|
* print resultset metadata information *
|
|
*********************************************************/
|
|
void my_print_result_metadata(MYSQL_RES *result)
|
|
{
|
|
MYSQL_FIELD *field;
|
|
unsigned int i,j;
|
|
unsigned int field_count;
|
|
|
|
mysql_field_seek(result,0);
|
|
fputc('\n', stdout);
|
|
|
|
field_count = mysql_num_fields(result);
|
|
for(i=0; i< field_count; i++)
|
|
{
|
|
field = mysql_fetch_field(result);
|
|
j = strlen(field->name);
|
|
if(j < field->max_length)
|
|
j = field->max_length;
|
|
if(j < 4 && !IS_NOT_NULL(field->flags))
|
|
j = 4;
|
|
field->max_length = j;
|
|
}
|
|
my_print_dashes(result);
|
|
fputc('\t',stdout);
|
|
fputc('|', stdout);
|
|
|
|
mysql_field_seek(result,0);
|
|
for(i=0; i< field_count; i++)
|
|
{
|
|
field = mysql_fetch_field(result);
|
|
fprintf(stdout, " %-*s |",(int) field->max_length, field->name);
|
|
}
|
|
fputc('\n', stdout);
|
|
my_print_dashes(result);
|
|
}
|
|
|
|
/********************************************************
|
|
* process the result set *
|
|
*********************************************************/
|
|
int my_process_result_set(MYSQL_RES *result)
|
|
{
|
|
MYSQL_ROW row;
|
|
MYSQL_FIELD *field;
|
|
unsigned int i;
|
|
unsigned int row_count=0;
|
|
|
|
my_print_result_metadata(result);
|
|
|
|
while((row = mysql_fetch_row(result)) != NULL)
|
|
{
|
|
mysql_field_seek(result,0);
|
|
fputc('\t',stdout);
|
|
fputc('|',stdout);
|
|
|
|
for(i=0; i< mysql_num_fields(result); i++)
|
|
{
|
|
field = mysql_fetch_field(result);
|
|
if(row[i] == NULL)
|
|
fprintf(stdout, " %-*s |", (int) field->max_length, "NULL");
|
|
else if (IS_NUM(field->type))
|
|
fprintf(stdout, " %*s |", (int) field->max_length, row[i]);
|
|
else
|
|
fprintf(stdout, " %-*s |", (int) field->max_length, row[i]);
|
|
}
|
|
fputc('\t',stdout);
|
|
fputc('\n',stdout);
|
|
row_count++;
|
|
}
|
|
my_print_dashes(result);
|
|
|
|
if (mysql_errno(mysql) != 0)
|
|
fprintf(stderr, "\n\tmysql_fetch_row() failed\n");
|
|
else
|
|
fprintf(stdout,"\n\t%d rows returned\n", row_count);
|
|
return(row_count);
|
|
}
|
|
|
|
static void verify_col_data(const char *table, const char *col, const char *exp_data)
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
MYSQL_BIND bind[1];
|
|
char data[255];
|
|
int rc;
|
|
|
|
init_bind(bind);
|
|
|
|
bind[0].buffer_type=FIELD_TYPE_STRING;
|
|
bind[0].buffer= (char *)data;
|
|
bind[0].buffer_length= sizeof(data);
|
|
|
|
sprintf(query, "SELECT `%s` FROM `%s`", col, table);
|
|
|
|
printf("\n %s", query);
|
|
stmt = mysql_prepare(mysql, query, strlen(query));
|
|
myxquery(stmt);
|
|
|
|
rc = mysql_bind_result(stmt,bind);
|
|
mystmt(stmt, rc);
|
|
|
|
rc = mysql_execute(stmt);
|
|
mystmt(stmt, rc);
|
|
|
|
rc = mysql_fetch(stmt);
|
|
mystmt(stmt,rc);
|
|
|
|
printf("\n data : %s (expected: %s)",data, exp_data);
|
|
assert(strcmp(data,exp_data)==0);
|
|
|
|
mysql_stmt_close(stmt);
|
|
}
|
|
|
|
/********************************************************
|
|
* store result processing *
|
|
*********************************************************/
|
|
void client_store_result()
|
|
{
|
|
MYSQL_RES *result;
|
|
int rc;
|
|
|
|
myheader("client_store_result");
|
|
|
|
rc = mysql_query(mysql, "SELECT * FROM myclient_test");
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_store_result(mysql);
|
|
mytest(result);
|
|
|
|
my_process_result_set(result);
|
|
mysql_free_result(result);
|
|
}
|
|
|
|
/********************************************************
|
|
* use result processing *
|
|
*********************************************************/
|
|
void client_use_result()
|
|
{
|
|
MYSQL_RES *result;
|
|
int rc;
|
|
myheader("client_use_result");
|
|
|
|
rc = mysql_query(mysql, "SELECT * FROM myclient_test");
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_use_result(mysql);
|
|
mytest(result);
|
|
|
|
my_process_result_set(result);
|
|
mysql_free_result(result);
|
|
}
|
|
|
|
|
|
/********************************************************
|
|
* query processing *
|
|
*********************************************************/
|
|
void test_debug_example()
|
|
{
|
|
int rc;
|
|
MYSQL_RES *result;
|
|
|
|
myheader("test_debug_example");
|
|
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_debug_example");
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"CREATE TABLE test_debug_example(id int primary key auto_increment,\
|
|
name varchar(20),xxx int)");
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"INSERT INTO test_debug_example(name) VALUES('mysql')");
|
|
myquery(rc);
|
|
|
|
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");
|
|
myquery(rc);
|
|
|
|
result = mysql_use_result(mysql);
|
|
mytest(result);
|
|
|
|
my_process_result_set(result);
|
|
mysql_free_result(result);
|
|
|
|
rc = mysql_query(mysql,"DROP TABLE test_debug_example");
|
|
myquery(rc);
|
|
}
|
|
|
|
/********************************************************
|
|
* to test autocommit feature *
|
|
*********************************************************/
|
|
void test_tran_bdb()
|
|
{
|
|
MYSQL_RES *result;
|
|
MYSQL_ROW row;
|
|
int rc;
|
|
|
|
myheader("test_tran_bdb");
|
|
|
|
/* set AUTOCOMMIT to OFF */
|
|
rc = mysql_autocommit(mysql, false);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS my_demo_transaction");
|
|
myquery(rc);
|
|
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* create the table 'mytran_demo' of type BDB' or 'InnoDB' */
|
|
rc = mysql_query(mysql,"CREATE TABLE my_demo_transaction(col1 int ,col2 varchar(30)) TYPE = BDB");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* insert a row and commit the transaction */
|
|
rc = mysql_query(mysql,"INSERT INTO my_demo_transaction 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 my_demo_transaction VALUES(20,'mysql')");
|
|
myquery(rc);
|
|
|
|
rc = mysql_rollback(mysql);
|
|
myquery(rc);
|
|
|
|
/* delete first row, and rollback it */
|
|
rc = mysql_query(mysql,"DELETE FROM my_demo_transaction WHERE col1 = 10");
|
|
myquery(rc);
|
|
|
|
rc = mysql_rollback(mysql);
|
|
myquery(rc);
|
|
|
|
/* test the results now, only one row should exists */
|
|
rc = mysql_query(mysql,"SELECT * FROM my_demo_transaction");
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_store_result(mysql);
|
|
mytest(result);
|
|
|
|
my_process_result_set(result);
|
|
|
|
/* test the results now, only one row should exists */
|
|
rc = mysql_query(mysql,"SELECT * FROM my_demo_transaction");
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_use_result(mysql);
|
|
mytest(result);
|
|
|
|
row = mysql_fetch_row(result);
|
|
mytest(row);
|
|
|
|
row = mysql_fetch_row(result);
|
|
mytest_r(row);
|
|
|
|
mysql_free_result(result);
|
|
mysql_autocommit(mysql,true);
|
|
}
|
|
|
|
/********************************************************
|
|
* to test autocommit feature *
|
|
*********************************************************/
|
|
void test_tran_innodb()
|
|
{
|
|
MYSQL_RES *result;
|
|
MYSQL_ROW row;
|
|
int rc;
|
|
|
|
myheader("test_tran_innodb");
|
|
|
|
/* set AUTOCOMMIT to OFF */
|
|
rc = mysql_autocommit(mysql, false);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS my_demo_transaction");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* create the table 'mytran_demo' of type BDB' or 'InnoDB' */
|
|
rc = mysql_query(mysql,"CREATE TABLE my_demo_transaction(col1 int ,col2 varchar(30)) TYPE = InnoDB");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* insert a row and commit the transaction */
|
|
rc = mysql_query(mysql,"INSERT INTO my_demo_transaction 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 my_demo_transaction VALUES(20,'mysql')");
|
|
myquery(rc);
|
|
|
|
rc = mysql_rollback(mysql);
|
|
myquery(rc);
|
|
|
|
/* delete first row, and rollback it */
|
|
rc = mysql_query(mysql,"DELETE FROM my_demo_transaction WHERE col1 = 10");
|
|
myquery(rc);
|
|
|
|
rc = mysql_rollback(mysql);
|
|
myquery(rc);
|
|
|
|
/* test the results now, only one row should exists */
|
|
rc = mysql_query(mysql,"SELECT * FROM my_demo_transaction");
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_store_result(mysql);
|
|
mytest(result);
|
|
|
|
my_process_result_set(result);
|
|
|
|
/* test the results now, only one row should exists */
|
|
rc = mysql_query(mysql,"SELECT * FROM my_demo_transaction");
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_use_result(mysql);
|
|
mytest(result);
|
|
|
|
row = mysql_fetch_row(result);
|
|
mytest(row);
|
|
|
|
row = mysql_fetch_row(result);
|
|
mytest_r(row);
|
|
|
|
mysql_free_result(result);
|
|
mysql_autocommit(mysql,true);
|
|
}
|
|
|
|
|
|
/********************************************************
|
|
To test simple prepares of all DML statements
|
|
*********************************************************/
|
|
|
|
void test_prepare_simple()
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
int rc,param_count;
|
|
|
|
myheader("test_prepare_simple");
|
|
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_prepare_simple");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"CREATE TABLE test_prepare_simple(id int, name varchar(50))");
|
|
myquery(rc);
|
|
|
|
/* alter table */
|
|
strcpy(query,"ALTER TABLE test_prepare_simple ADD new char(20)");
|
|
stmt = mysql_prepare(mysql, query, strlen(query));
|
|
myxquery(stmt);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
fprintf(stdout,"\n total parameters in alter:%d\n", param_count);
|
|
assert(param_count == 0);
|
|
mysql_stmt_close(stmt);
|
|
|
|
/* insert */
|
|
strcpy(query,"INSERT INTO test_prepare_simple VALUES(?,?)");
|
|
stmt = mysql_prepare(mysql, query, strlen(query));
|
|
myxquery(stmt);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
fprintf(stdout,"\n total parameters in insert:%d\n", param_count);
|
|
assert(param_count == 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);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
fprintf(stdout,"\n total parameters in update:%d\n", param_count);
|
|
assert(param_count == 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);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
fprintf(stdout,"\n total parameters in delete:%d\n", param_count);
|
|
assert(param_count == 0);
|
|
|
|
rc = mysql_execute(stmt);
|
|
mystmt(stmt, rc);
|
|
mysql_stmt_close(stmt);
|
|
|
|
/* delete */
|
|
strcpy(query,"DELETE FROM test_prepare_simple WHERE id=?");
|
|
stmt = mysql_prepare(mysql, query, strlen(query));
|
|
myxquery(stmt);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
fprintf(stdout,"\n total parameters in delete:%d\n", param_count);
|
|
assert(param_count == 1);
|
|
|
|
rc = mysql_execute(stmt);
|
|
mystmt_r(stmt, rc);
|
|
mysql_stmt_close(stmt);
|
|
|
|
/* select */
|
|
strcpy(query,"SELECT * FROM test_prepare_simple WHERE id=? AND name= ?");
|
|
stmt = mysql_prepare(mysql, query, strlen(query));
|
|
myxquery(stmt);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
fprintf(stdout,"\n total parameters in select:%d\n", param_count);
|
|
assert(param_count == 2);
|
|
|
|
mysql_stmt_close(stmt);
|
|
|
|
/* now fetch the results ..*/
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
}
|
|
|
|
|
|
/********************************************************
|
|
* to test simple prepare field results *
|
|
*********************************************************/
|
|
void test_prepare_field_result()
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
int rc,param_count;
|
|
|
|
myheader("test_prepare_field_result");
|
|
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_prepare_field_result");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"CREATE TABLE test_prepare_field_result(id int, name varchar(50), extra int)");
|
|
myquery(rc);
|
|
|
|
/* insert */
|
|
strcpy(query,"SELECT id,name FROM test_prepare_field_result WHERE id=?");
|
|
stmt = mysql_prepare(mysql, query, strlen(query));
|
|
myxquery(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);
|
|
|
|
/* now fetch the results ..*/
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
}
|
|
|
|
|
|
/********************************************************
|
|
* to test simple prepare field results *
|
|
*********************************************************/
|
|
void test_prepare_syntax()
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
int rc;
|
|
|
|
myheader("test_prepare_syntax");
|
|
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_prepare_syntax");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"CREATE TABLE test_prepare_syntax(id int, name varchar(50), extra int)");
|
|
myquery(rc);
|
|
|
|
strcpy(query,"INSERT INTO test_prepare_syntax VALUES(?");
|
|
stmt = mysql_prepare(mysql, query, strlen(query));
|
|
myxquery_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);
|
|
|
|
/* now fetch the results ..*/
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
}
|
|
|
|
|
|
/********************************************************
|
|
* to test simple prepare *
|
|
*********************************************************/
|
|
void test_prepare()
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
int rc,param_count;
|
|
char query[200];
|
|
int int_data;
|
|
char str_data[50];
|
|
char tiny_data;
|
|
short small_data;
|
|
longlong big_data;
|
|
double real_data;
|
|
double double_data;
|
|
MYSQL_RES *result;
|
|
MYSQL_BIND bind[8];
|
|
|
|
myheader("test_prepare");
|
|
|
|
init_bind(bind);
|
|
rc = mysql_autocommit(mysql, true);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS my_prepare");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"CREATE TABLE my_prepare(col1 tinyint,\
|
|
col2 varchar(50), col3 int,\
|
|
col4 smallint, col5 bigint, \
|
|
col6 float, col7 double )");
|
|
myquery(rc);
|
|
|
|
/* insert by prepare */
|
|
strcpy(query,"INSERT INTO my_prepare VALUES(?,?,?,?,?,?,?)");
|
|
stmt = mysql_prepare(mysql, query, strlen(query));
|
|
myxquery(stmt);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
fprintf(stdout," total parameters in insert:%d\n", param_count);
|
|
assert(param_count == 7);
|
|
|
|
/* tinyint */
|
|
bind[0].buffer_type=FIELD_TYPE_TINY;
|
|
bind[0].buffer=(gptr)&tiny_data;
|
|
/* string */
|
|
bind[1].buffer_type=FIELD_TYPE_STRING;
|
|
bind[1].buffer=str_data;
|
|
bind[1].buffer_length=sizeof(str_data);
|
|
/* integer */
|
|
bind[2].buffer_type=FIELD_TYPE_LONG;
|
|
bind[2].buffer= (gptr)&int_data;
|
|
/* short */
|
|
bind[3].buffer_type=FIELD_TYPE_SHORT;
|
|
bind[3].buffer= (gptr)&small_data;
|
|
/* bigint */
|
|
bind[4].buffer_type=FIELD_TYPE_LONGLONG;
|
|
bind[4].buffer= (gptr)&big_data;
|
|
/* float */
|
|
bind[5].buffer_type=FIELD_TYPE_DOUBLE;
|
|
bind[5].buffer= (gptr)&real_data;
|
|
/* double */
|
|
bind[6].buffer_type=FIELD_TYPE_DOUBLE;
|
|
bind[6].buffer= (gptr)&double_data;
|
|
|
|
rc = mysql_bind_param(stmt,bind);
|
|
mystmt(stmt, rc);
|
|
|
|
int_data = 320;
|
|
small_data = 1867;
|
|
big_data = 1000;
|
|
real_data = 2;
|
|
double_data = 6578.001;
|
|
|
|
/* now, execute the prepared statement to insert 10 records.. */
|
|
for (tiny_data=0; tiny_data < 100; tiny_data++)
|
|
{
|
|
bind[1].buffer_length = sprintf(str_data,"MySQL%d",int_data);
|
|
rc = mysql_execute(stmt);
|
|
mystmt(stmt, rc);
|
|
int_data += 25;
|
|
small_data += 10;
|
|
big_data += 100;
|
|
real_data += 1;
|
|
double_data += 10.09;
|
|
}
|
|
|
|
mysql_stmt_close(stmt);
|
|
|
|
/* now fetch the results ..*/
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* test the results now, only one row should exists */
|
|
rc = mysql_query(mysql,"SELECT * FROM my_prepare");
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_store_result(mysql);
|
|
mytest(result);
|
|
|
|
assert((int)tiny_data == my_process_result_set(result));
|
|
mysql_free_result(result);
|
|
|
|
}
|
|
|
|
/********************************************************
|
|
* to test double comparision *
|
|
*********************************************************/
|
|
void test_double_compare()
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
int rc,param_count;
|
|
char query[200],real_data[10], tiny_data;
|
|
double double_data;
|
|
MYSQL_RES *result;
|
|
MYSQL_BIND bind[3];
|
|
|
|
myheader("test_double_compare");
|
|
|
|
init_bind(bind);
|
|
rc = mysql_autocommit(mysql, true);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_double_compare");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"CREATE TABLE test_double_compare(col1 tinyint,\
|
|
col2 float, col3 double )");
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"INSERT INTO test_double_compare VALUES(1,10.2,34.5)");
|
|
myquery(rc);
|
|
|
|
strcpy(query, "UPDATE test_double_compare SET col1=100 WHERE col1 = ? AND col2 = ? AND COL3 = ?");
|
|
stmt = mysql_prepare(mysql,query, strlen(query));
|
|
myxquery(stmt);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
fprintf(stdout," total parameters in update:%d\n", param_count);
|
|
|
|
/* tinyint */
|
|
bind[0].buffer_type=FIELD_TYPE_TINY;
|
|
bind[0].buffer=(gptr)&tiny_data;
|
|
/* string->float */
|
|
bind[1].buffer_type=FIELD_TYPE_STRING;
|
|
bind[1].buffer= (gptr)&real_data;
|
|
bind[1].buffer_length=10;
|
|
/* double */
|
|
bind[2].buffer_type=FIELD_TYPE_DOUBLE;
|
|
bind[2].buffer= (gptr)&double_data;
|
|
|
|
tiny_data = 1;
|
|
strcpy(real_data,"10.2");
|
|
double_data = 34.5;
|
|
rc = mysql_bind_param(stmt,bind);
|
|
mystmt(stmt, rc);
|
|
|
|
rc = mysql_execute(stmt);
|
|
mystmt(stmt, rc);
|
|
|
|
rc = (int)mysql_affected_rows(mysql);
|
|
printf("\n total affected rows:%d",rc);
|
|
|
|
mysql_stmt_close(stmt);
|
|
|
|
/* now fetch the results ..*/
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* test the results now, only one row should exists */
|
|
rc = mysql_query(mysql,"SELECT * FROM test_double_compare");
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_store_result(mysql);
|
|
mytest(result);
|
|
|
|
assert((int)tiny_data == my_process_result_set(result));
|
|
mysql_free_result(result);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/********************************************************
|
|
* to test simple null *
|
|
*********************************************************/
|
|
void test_null()
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
int rc,param_count;
|
|
int nData=1;
|
|
MYSQL_RES *result;
|
|
MYSQL_BIND bind[2];
|
|
|
|
myheader("test_null");
|
|
|
|
init_bind(bind);
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_null");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"CREATE TABLE test_null(col1 int,col2 varchar(50))");
|
|
myquery(rc);
|
|
|
|
/* 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);
|
|
|
|
strcpy(query,"INSERT INTO test_null(col1,col2) VALUES(?,?)");
|
|
stmt = mysql_prepare(mysql, query, strlen(query));
|
|
myxquery(stmt);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
fprintf(stdout," total parameters in insert:%d\n", param_count);
|
|
assert(param_count == 2);
|
|
|
|
bind[0].is_null=1;
|
|
bind[0].buffer_type=MYSQL_TYPE_NULL;
|
|
bind[1]=bind[0]; /* string data */
|
|
|
|
rc = mysql_bind_param(stmt,bind);
|
|
mystmt(stmt, rc);
|
|
|
|
/* now, execute the prepared statement to insert 10 records.. */
|
|
for (nData=0; nData<9; nData++)
|
|
{
|
|
rc = mysql_execute(stmt);
|
|
mystmt(stmt, rc);
|
|
}
|
|
mysql_stmt_close(stmt);
|
|
|
|
/* now fetch the results ..*/
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* test the results now, only one row should exists */
|
|
rc = mysql_query(mysql,"SELECT * FROM test_null");
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_store_result(mysql);
|
|
mytest(result);
|
|
|
|
assert(nData == my_process_result_set(result));
|
|
mysql_free_result(result);
|
|
}
|
|
|
|
|
|
|
|
/********************************************************
|
|
* to test simple select *
|
|
*********************************************************/
|
|
void test_select_simple()
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
int rc,length;
|
|
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);
|
|
|
|
length = mysql_param_count(stmt);
|
|
fprintf(stdout," total parameters in select:%d\n", length);
|
|
assert(length == 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);
|
|
|
|
#if 0
|
|
strcpy((char *)query , "SELECT @@ VERSION");
|
|
length = strlen(query);
|
|
rc = mysql_query(mysql,query);
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_store_result(mysql);
|
|
mytest(result);
|
|
|
|
my_process_result_set(result);
|
|
mysql_free_result(result);
|
|
#endif
|
|
}
|
|
|
|
|
|
/********************************************************
|
|
* to test simple select *
|
|
*********************************************************/
|
|
void test_select()
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
int rc,param_count=0;
|
|
char *szData=(char *)"updated-value";
|
|
int nData=1;
|
|
MYSQL_BIND bind[2];
|
|
MYSQL_RES *result;
|
|
|
|
|
|
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));
|
|
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 */
|
|
result = mysql_store_result(mysql);
|
|
mytest(result);
|
|
|
|
assert( 1 == my_process_result_set(result));
|
|
mysql_free_result(result);
|
|
|
|
mysql_stmt_close(stmt);
|
|
|
|
/* bit complicated SELECT */
|
|
}
|
|
|
|
|
|
|
|
|
|
/********************************************************
|
|
* to test simple update *
|
|
*********************************************************/
|
|
void test_simple_update()
|
|
{
|
|
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);
|
|
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);
|
|
|
|
assert(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));
|
|
myxquery(stmt);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
fprintf(stdout," total parameters in update:%d\n", param_count);
|
|
assert(param_count == 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[1].buffer=(gptr)&nData;
|
|
bind[1].buffer_type=FIELD_TYPE_LONG;
|
|
|
|
rc = mysql_bind_param(stmt,bind);
|
|
mystmt(stmt, rc);
|
|
|
|
rc = mysql_execute(stmt);
|
|
mystmt(stmt, rc);
|
|
assert(1 == mysql_affected_rows(mysql));
|
|
|
|
mysql_stmt_close(stmt);
|
|
|
|
/* now fetch the results ..*/
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* test the results now, only one row should exists */
|
|
rc = mysql_query(mysql,"SELECT * FROM test_update");
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_store_result(mysql);
|
|
mytest(result);
|
|
|
|
assert(1 == my_process_result_set(result));
|
|
mysql_free_result(result);
|
|
}
|
|
|
|
|
|
/********************************************************
|
|
* to test simple long data handling *
|
|
*********************************************************/
|
|
void test_long_data()
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
int rc,param_count, int_data=10;
|
|
char *data=NullS;
|
|
MYSQL_RES *result;
|
|
MYSQL_BIND bind[3];
|
|
|
|
|
|
myheader("test_long_data");
|
|
|
|
init_bind(bind);
|
|
rc = mysql_autocommit(mysql,true);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_long_data");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"CREATE TABLE test_long_data(col1 int,\
|
|
col2 long varchar, col3 long varbinary)");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
strcpy(query,"INSERT INTO test_long_data(col1,col2) VALUES(?)");
|
|
stmt = mysql_prepare(mysql, query, strlen(query));
|
|
myxquery_r(stmt);
|
|
|
|
strcpy(query,"INSERT INTO test_long_data(col1,col2,col3) VALUES(?,?,?)");
|
|
stmt = mysql_prepare(mysql, query, strlen(query));
|
|
myxquery(stmt);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
fprintf(stdout," total parameters in insert:%d\n", param_count);
|
|
assert(param_count == 3);
|
|
|
|
bind[0].buffer=(char *)&int_data;
|
|
bind[0].buffer_type=FIELD_TYPE_LONG;
|
|
bind[1].is_long_data=1; /* specify long data suppy during run-time */
|
|
|
|
/* 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);
|
|
mystmt_r(stmt, rc);
|
|
|
|
bind[1].buffer_type=FIELD_TYPE_STRING;
|
|
bind[2]=bind[1];
|
|
rc = mysql_bind_param(stmt,bind);
|
|
mystmt(stmt, rc);
|
|
|
|
rc = mysql_execute(stmt);
|
|
fprintf(stdout,"mysql_execute() returned %d\n",rc);
|
|
assert(rc == MYSQL_NEED_DATA);
|
|
|
|
data = (char *)"Micheal";
|
|
|
|
/* supply data in pieces */
|
|
rc = mysql_send_long_data(stmt,1,data,7,1);
|
|
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);
|
|
|
|
/* append data again ..*/
|
|
|
|
/* Indicate end of data */
|
|
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);
|
|
mystmt(stmt, rc);
|
|
|
|
/* execute */
|
|
rc = mysql_execute(stmt);
|
|
fprintf(stdout,"mysql_execute() returned %d\n",rc);
|
|
mystmt(stmt,rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* now fetch the results ..*/
|
|
rc = mysql_query(mysql,"SELECT * FROM test_long_data");
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_store_result(mysql);
|
|
mytest(result);
|
|
|
|
assert(1 == my_process_result_set(result));
|
|
mysql_free_result(result);
|
|
}
|
|
|
|
/********************************************************
|
|
* to test long data (string) handling *
|
|
*********************************************************/
|
|
void test_long_data_str()
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
int rc,param_count;
|
|
char data[255];
|
|
long length;
|
|
MYSQL_RES *result;
|
|
MYSQL_BIND bind[2];
|
|
|
|
|
|
myheader("test_long_data_str");
|
|
|
|
init_bind(bind);
|
|
rc = mysql_autocommit(mysql,true);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_long_data_str");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"CREATE TABLE test_long_data_str(id int, longstr long varchar)");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
strcpy(query,"INSERT INTO test_long_data_str VALUES(?,?)");
|
|
stmt = mysql_prepare(mysql, query, strlen(query));
|
|
myxquery(stmt);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
fprintf(stdout," total parameters in insert:%d\n", param_count);
|
|
assert(param_count == 2);
|
|
|
|
bind[0].buffer = (gptr)&length;
|
|
bind[0].buffer_type = FIELD_TYPE_LONG;
|
|
|
|
bind[1].buffer=data; /* string data */
|
|
bind[1].is_long_data=1; /* specify long data suppy during run-time */
|
|
bind[1].buffer_type=FIELD_TYPE_STRING;
|
|
rc = mysql_bind_param(stmt,bind);
|
|
mystmt(stmt, rc);
|
|
|
|
length = 10;
|
|
rc = mysql_execute(stmt);
|
|
fprintf(stdout,"mysql_execute() returned %d\n",rc);
|
|
assert(rc == MYSQL_NEED_DATA);
|
|
|
|
length = 40;
|
|
sprintf(data,"MySQL AB");
|
|
|
|
/* supply data in pieces */
|
|
{
|
|
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);
|
|
}
|
|
|
|
/* Indiate end of data supply */
|
|
rc = mysql_send_long_data(stmt,1,0,0,1);
|
|
mystmt(stmt, rc);
|
|
|
|
/* execute */
|
|
rc = mysql_execute(stmt);
|
|
fprintf(stdout,"mysql_execute() returned %d\n",rc);
|
|
mystmt(stmt,rc);
|
|
|
|
mysql_stmt_close(stmt);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* now fetch the results ..*/
|
|
rc = mysql_query(mysql,"SELECT LENGTH(longstr), longstr FROM test_long_data_str");
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_store_result(mysql);
|
|
mytest(result);
|
|
|
|
assert(1 == my_process_result_set(result));
|
|
mysql_free_result(result);
|
|
}
|
|
|
|
|
|
/********************************************************
|
|
* to test long data (string) handling *
|
|
*********************************************************/
|
|
void test_long_data_str1()
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
int rc,param_count;
|
|
char *data=(char *)"MySQL AB";
|
|
int length;
|
|
MYSQL_RES *result;
|
|
MYSQL_BIND bind[2];
|
|
|
|
|
|
myheader("test_long_data_str1");
|
|
|
|
init_bind(bind);
|
|
rc = mysql_autocommit(mysql,true);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_long_data_str");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"CREATE TABLE test_long_data_str(longstr long varchar,blb long varbinary)");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
strcpy(query,"INSERT INTO test_long_data_str VALUES(?,?)");
|
|
stmt = mysql_prepare(mysql, query, strlen(query));
|
|
myxquery(stmt);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
fprintf(stdout," total parameters in insert:%d\n", param_count);
|
|
assert(param_count == 2);
|
|
|
|
bind[0].buffer=data; /* string data */
|
|
bind[0].is_long_data=1; /* specify long data suppy during run-time */
|
|
bind[0].buffer_type=FIELD_TYPE_STRING;
|
|
|
|
bind[1] = bind[0];
|
|
bind[1].buffer_type=FIELD_TYPE_BLOB;
|
|
|
|
rc = mysql_bind_param(stmt,bind);
|
|
mystmt(stmt, rc);
|
|
|
|
length = 10;
|
|
rc = mysql_execute(stmt);
|
|
fprintf(stdout,"mysql_execute() returned %d\n",rc);
|
|
assert(rc == MYSQL_NEED_DATA);
|
|
|
|
length = strlen(data);
|
|
|
|
/* supply data in pieces */
|
|
{
|
|
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,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);
|
|
}
|
|
|
|
/* 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);
|
|
|
|
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);
|
|
mystmt(stmt,rc);
|
|
|
|
mysql_stmt_close(stmt);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* now fetch the results ..*/
|
|
rc = mysql_query(mysql,"SELECT LENGTH(longstr),longstr,LENGTH(blb),blb FROM test_long_data_str");
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_store_result(mysql);
|
|
mytest(result);
|
|
|
|
assert(1 == my_process_result_set(result));
|
|
mysql_free_result(result);
|
|
}
|
|
|
|
|
|
/********************************************************
|
|
* to test long data (binary) handling *
|
|
*********************************************************/
|
|
void test_long_data_bin()
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
int rc,param_count;
|
|
char data[255];
|
|
int length;
|
|
MYSQL_RES *result;
|
|
MYSQL_BIND bind[2];
|
|
|
|
|
|
myheader("test_long_data_bin");
|
|
|
|
init_bind(bind);
|
|
rc = mysql_autocommit(mysql,true);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_long_data_bin");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"CREATE TABLE test_long_data_bin(id int, longbin long varbinary)");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
strcpy(query,"INSERT INTO test_long_data_bin VALUES(?,?)");
|
|
stmt = mysql_prepare(mysql, query, strlen(query));
|
|
myxquery(stmt);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
fprintf(stdout," total parameters in insert:%d\n", param_count);
|
|
assert(param_count == 2);
|
|
|
|
bind[0].buffer = (gptr)&length;
|
|
bind[0].buffer_type = FIELD_TYPE_LONG;
|
|
|
|
bind[1].buffer=data; /* string data */
|
|
bind[1].is_long_data=1; /* specify long data suppy during run-time */
|
|
bind[1].buffer_type=FIELD_TYPE_LONG_BLOB;
|
|
rc = mysql_bind_param(stmt,bind);
|
|
mystmt(stmt, rc);
|
|
|
|
length = 10;
|
|
rc = mysql_execute(stmt);
|
|
fprintf(stdout,"mysql_execute() returned %d\n",rc);
|
|
assert(rc == MYSQL_NEED_DATA);
|
|
|
|
sprintf(data,"MySQL AB");
|
|
|
|
/* supply data in pieces */
|
|
{
|
|
int i;
|
|
for(i=0; i < 100; i++)
|
|
{
|
|
rc = mysql_send_long_data(stmt,1,(char *)data,4,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);
|
|
}
|
|
|
|
/* Indiate end of data supply */
|
|
rc = mysql_send_long_data(stmt,1,0,0,1);
|
|
mystmt(stmt, rc);
|
|
|
|
/* execute */
|
|
rc = mysql_execute(stmt);
|
|
fprintf(stdout,"mysql_execute() returned %d\n",rc);
|
|
mystmt(stmt,rc);
|
|
|
|
mysql_stmt_close(stmt);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* now fetch the results ..*/
|
|
rc = mysql_query(mysql,"SELECT LENGTH(longbin), longbin FROM test_long_data_bin");
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_store_result(mysql);
|
|
mytest(result);
|
|
|
|
assert(1 == my_process_result_set(result));
|
|
mysql_free_result(result);
|
|
}
|
|
|
|
|
|
/********************************************************
|
|
* to test simple delete *
|
|
*********************************************************/
|
|
void test_simple_delete()
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
int rc,param_count;
|
|
char szData[30]={0};
|
|
int nData=1;
|
|
MYSQL_RES *result;
|
|
MYSQL_BIND bind[2];
|
|
|
|
|
|
myheader("test_simple_delete");
|
|
|
|
init_bind(bind);
|
|
rc = mysql_autocommit(mysql,true);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_simple_delete");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"CREATE TABLE test_simple_delete(col1 int,\
|
|
col2 varchar(50), col3 int )");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"INSERT INTO test_simple_delete VALUES(1,'MySQL',100)");
|
|
myquery(rc);
|
|
|
|
assert(1 == mysql_affected_rows(mysql));
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* 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);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
fprintf(stdout," total parameters in delete:%d\n", param_count);
|
|
assert(param_count == 2);
|
|
|
|
nData=1;
|
|
strcpy(szData,"MySQL");
|
|
bind[1].buffer_length = 5;
|
|
bind[1].buffer_type=FIELD_TYPE_STRING;
|
|
bind[1].buffer=szData; /* string data */
|
|
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);
|
|
assert(1 == mysql_affected_rows(mysql));
|
|
|
|
mysql_stmt_close(stmt);
|
|
|
|
/* now fetch the results ..*/
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* test the results now, only one row should exists */
|
|
rc = mysql_query(mysql,"SELECT * FROM test_simple_delete");
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_store_result(mysql);
|
|
mytest(result);
|
|
|
|
assert(0 == my_process_result_set(result));
|
|
mysql_free_result(result);
|
|
}
|
|
|
|
|
|
|
|
/********************************************************
|
|
* to test simple update *
|
|
*********************************************************/
|
|
void test_update()
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
int rc,param_count;
|
|
char szData[25];
|
|
int nData=1;
|
|
MYSQL_RES *result;
|
|
MYSQL_BIND bind[2];
|
|
|
|
|
|
myheader("test_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 primary key auto_increment,\
|
|
col2 varchar(50), col3 int )");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
strcpy(query,"INSERT INTO test_update(col2,col3) VALUES(?,?)");
|
|
stmt = mysql_prepare(mysql, query, strlen(query));
|
|
myxquery(stmt);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
fprintf(stdout," total parameters in insert:%d\n", param_count);
|
|
assert(param_count == 2);
|
|
|
|
/* string data */
|
|
bind[0].buffer_type=FIELD_TYPE_STRING;
|
|
bind[0].buffer=szData;
|
|
bind[0].buffer_length=sprintf(szData,"inserted-data");
|
|
bind[1].buffer=(gptr)&nData;
|
|
bind[1].buffer_type=FIELD_TYPE_LONG;
|
|
|
|
rc = mysql_bind_param(stmt,bind);
|
|
mystmt(stmt, rc);
|
|
|
|
nData=100;
|
|
rc = mysql_execute(stmt);
|
|
mystmt(stmt, rc);
|
|
|
|
assert(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);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
fprintf(stdout," total parameters in update:%d\n", param_count);
|
|
assert(param_count == 2);
|
|
nData=100;
|
|
|
|
|
|
bind[0].buffer_type=FIELD_TYPE_STRING;
|
|
bind[0].buffer=szData;
|
|
bind[0].buffer_length=sprintf(szData,"updated-data");
|
|
bind[1].buffer=(gptr)&nData;
|
|
bind[1].buffer_type=FIELD_TYPE_LONG;
|
|
|
|
rc = mysql_bind_param(stmt,bind);
|
|
mystmt(stmt, rc);
|
|
|
|
rc = mysql_execute(stmt);
|
|
mystmt(stmt, rc);
|
|
assert(1 == mysql_affected_rows(mysql));
|
|
|
|
mysql_stmt_close(stmt);
|
|
|
|
/* now fetch the results ..*/
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* test the results now, only one row should exists */
|
|
rc = mysql_query(mysql,"SELECT * FROM test_update");
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_store_result(mysql);
|
|
mytest(result);
|
|
|
|
assert(1 == my_process_result_set(result));
|
|
mysql_free_result(result);
|
|
}
|
|
|
|
|
|
/********************************************************
|
|
* to test simple prepare *
|
|
*********************************************************/
|
|
void test_init_prepare()
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
int param_count, rc;
|
|
MYSQL_RES *result;
|
|
|
|
myheader("test_init_prepare");
|
|
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS my_prepare");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"CREATE TABLE my_prepare(col1 int ,col2 varchar(50))");
|
|
myquery(rc);
|
|
|
|
|
|
/* insert by prepare */
|
|
strcpy(query,"INSERT INTO my_prepare VALUES(10,'venu')");
|
|
stmt = mysql_prepare(mysql, query, strlen(query));
|
|
myxquery(stmt);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
fprintf(stdout," total parameters in insert:%d\n", param_count);
|
|
assert(param_count == 0);
|
|
|
|
rc = mysql_execute(stmt);
|
|
mystmt(stmt, rc);
|
|
|
|
mysql_stmt_close(stmt);
|
|
|
|
/* now fetch the results ..*/
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* test the results now, only one row should exists */
|
|
rc = mysql_query(mysql,"SELECT * FROM my_prepare");
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_store_result(mysql);
|
|
mytest(result);
|
|
|
|
assert(1 == my_process_result_set(result));
|
|
mysql_free_result(result);
|
|
}
|
|
|
|
|
|
/********************************************************
|
|
* to test simple bind result *
|
|
*********************************************************/
|
|
void test_bind_result()
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
int rc;
|
|
const char query[100];
|
|
int nData;
|
|
char szData[100];
|
|
MYSQL_BIND bind[2];
|
|
|
|
myheader("test_bind_result");
|
|
|
|
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(col1 int ,col2 varchar(50))");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"INSERT INTO test_bind_result VALUES(10,'venu')");
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"INSERT INTO test_bind_result VALUES(20,'MySQL')");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* fetch */
|
|
|
|
bind[0].buffer_type=FIELD_TYPE_LONG;
|
|
bind[0].buffer= (gptr) &nData; /* integer data */
|
|
bind[1].buffer_type=FIELD_TYPE_STRING;
|
|
bind[1].buffer=szData; /* string data */
|
|
bind[1].buffer_length=sizeof(szData);
|
|
|
|
strcpy((char *)query , "SELECT * FROM test_bind_result");
|
|
stmt = mysql_prepare(mysql, query, strlen(query));
|
|
myxquery(stmt);
|
|
|
|
rc = mysql_bind_result(stmt,bind);
|
|
mystmt(stmt, rc);
|
|
|
|
rc = mysql_execute(stmt);
|
|
mystmt(stmt, rc);
|
|
|
|
rc = mysql_fetch(stmt);
|
|
mystmt(stmt,rc);
|
|
|
|
printf("\n row 1:%d,%s",nData, szData);
|
|
assert(nData == 10);
|
|
assert(strcmp(szData,"venu")==0);
|
|
|
|
rc = mysql_fetch(stmt);
|
|
mystmt(stmt,rc);
|
|
|
|
printf("\n row 2:%d,%s",nData, szData);
|
|
assert(nData == 20);
|
|
assert(strcmp(szData,"MySQL")==0);
|
|
|
|
rc = mysql_fetch(stmt);
|
|
assert(rc == MYSQL_NO_DATA);
|
|
|
|
mysql_stmt_close(stmt);
|
|
}
|
|
|
|
/********************************************************
|
|
* to test simple prepare with all possible types *
|
|
*********************************************************/
|
|
void test_prepare_ext()
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
int rc,param_count;
|
|
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,\
|
|
c26 text,\
|
|
c27 mediumblob,\
|
|
c28 mediumtext,\
|
|
c29 longblob,\
|
|
c30 longtext,\
|
|
c31 enum('one','two','three'),\
|
|
c32 set('monday','tuesday','wednesday'))";
|
|
|
|
rc = mysql_query(mysql,sql);
|
|
myquery(rc);
|
|
|
|
/* insert by prepare - all integers */
|
|
strcpy(query,(char *)"INSERT INTO test_prepare_ext(c1,c2,c3,c4,c5,c6) VALUES(?,?,?,?,?,?)");
|
|
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);
|
|
|
|
/*tinyint*/
|
|
bind_int[0].buffer_type=FIELD_TYPE_TINY;
|
|
bind_int[0].buffer= (void *)&tData;
|
|
|
|
/*smallint*/
|
|
bind_int[1].buffer_type=FIELD_TYPE_SHORT;
|
|
bind_int[1].buffer= (void *)&sData;
|
|
|
|
/*mediumint*/
|
|
bind_int[2].buffer_type=FIELD_TYPE_LONG;
|
|
bind_int[2].buffer= (void *)&nData;
|
|
|
|
/*int*/
|
|
bind_int[3].buffer_type=FIELD_TYPE_LONG;
|
|
bind_int[3].buffer= (void *)&nData;
|
|
|
|
/*integer*/
|
|
bind_int[4].buffer_type=FIELD_TYPE_LONG;
|
|
bind_int[4].buffer= (void *)&nData;
|
|
|
|
/*bigint*/
|
|
bind_int[5].buffer_type=FIELD_TYPE_LONGLONG;
|
|
bind_int[5].buffer= (void *)&bData;
|
|
|
|
rc = mysql_bind_param(stmt,bind_int);
|
|
mystmt(stmt, rc);
|
|
|
|
/*
|
|
* integer to integer
|
|
*/
|
|
for (nData=0; nData<10; nData++, tData++, sData++,bData++)
|
|
{
|
|
rc = mysql_execute(stmt);
|
|
mystmt(stmt, rc);
|
|
}
|
|
mysql_stmt_close(stmt);
|
|
|
|
/* now fetch the results ..*/
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* test the results now, only one row should exists */
|
|
rc = mysql_query(mysql,"SELECT c1,c2,c3,c4,c5,c6 FROM test_prepare_ext");
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_store_result(mysql);
|
|
mytest(result);
|
|
|
|
assert(nData == my_process_result_set(result));
|
|
mysql_free_result(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
/********************************************************
|
|
* to test real and alias names *
|
|
*********************************************************/
|
|
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);
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_field_names1");
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_field_names2");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"CREATE TABLE test_field_names1(id int,name varchar(50))");
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"CREATE TABLE test_field_names2(id int,name varchar(50))");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* with table name included with true column name */
|
|
rc = mysql_query(mysql,"SELECT id as 'id-alias' FROM test_field_names1");
|
|
myquery(rc);
|
|
|
|
result = mysql_use_result(mysql);
|
|
mytest(result);
|
|
|
|
assert(0 == my_process_result_set(result));
|
|
mysql_free_result(result);
|
|
|
|
/* with table name included with true column name */
|
|
rc = mysql_query(mysql,"SELECT t1.id as 'id-alias',test_field_names2.name FROM test_field_names1 t1,test_field_names2");
|
|
myquery(rc);
|
|
|
|
result = mysql_use_result(mysql);
|
|
mytest(result);
|
|
|
|
assert(0 == my_process_result_set(result));
|
|
mysql_free_result(result);
|
|
}
|
|
|
|
/********************************************************
|
|
* to test warnings *
|
|
*********************************************************/
|
|
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);
|
|
|
|
result = mysql_use_result(mysql);
|
|
mytest(result);
|
|
|
|
my_process_result_set(result);
|
|
mysql_free_result(result);
|
|
}
|
|
|
|
/********************************************************
|
|
* to test errors *
|
|
*********************************************************/
|
|
void test_errors()
|
|
{
|
|
int rc;
|
|
MYSQL_RES *result;
|
|
|
|
myheader("test_errors");
|
|
|
|
rc = mysql_query(mysql,"SHOW ERRORS");
|
|
myquery(rc);
|
|
|
|
result = mysql_use_result(mysql);
|
|
mytest(result);
|
|
|
|
my_process_result_set(result);
|
|
mysql_free_result(result);
|
|
}
|
|
|
|
|
|
|
|
/********************************************************
|
|
* to test simple prepare-insert *
|
|
*********************************************************/
|
|
void test_insert()
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
int rc,param_count, length;
|
|
char query[200];
|
|
char str_data[50];
|
|
char tiny_data;
|
|
MYSQL_RES *result;
|
|
MYSQL_BIND bind[2];
|
|
|
|
myheader("test_insert");
|
|
|
|
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))");
|
|
myquery(rc);
|
|
|
|
/* insert by prepare */
|
|
bzero(bind, sizeof(bind));
|
|
strcpy(query,"INSERT INTO test_prep_insert VALUES(?,?)");
|
|
stmt = mysql_prepare(mysql, query, strlen(query));
|
|
myxquery(stmt);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
fprintf(stdout," total parameters in insert:%d\n", param_count);
|
|
assert(param_count == 2);
|
|
|
|
/* tinyint */
|
|
bind[0].buffer_type=FIELD_TYPE_TINY;
|
|
bind[0].buffer=(gptr)&tiny_data;
|
|
/* string */
|
|
bind[1].buffer_type=FIELD_TYPE_STRING;
|
|
bind[1].buffer=str_data;
|
|
bind[1].length=(long *)&length;
|
|
|
|
rc = mysql_bind_param(stmt,bind);
|
|
mystmt(stmt, rc);
|
|
|
|
/* now, execute the prepared statement to insert 10 records.. */
|
|
for (tiny_data=0; tiny_data < 3; tiny_data++)
|
|
{
|
|
length = sprintf(str_data,"MySQL%d",tiny_data);
|
|
rc = mysql_execute(stmt);
|
|
mystmt(stmt, rc);
|
|
}
|
|
|
|
mysql_stmt_close(stmt);
|
|
|
|
/* now fetch the results ..*/
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* test the results now, only one row should exists */
|
|
rc = mysql_query(mysql,"SELECT * FROM test_prep_insert");
|
|
myquery(rc);
|
|
|
|
/* get the result */
|
|
result = mysql_store_result(mysql);
|
|
mytest(result);
|
|
|
|
assert((int)tiny_data == my_process_result_set(result));
|
|
mysql_free_result(result);
|
|
|
|
}
|
|
|
|
/********************************************************
|
|
* to test simple prepare-resultset info *
|
|
*********************************************************/
|
|
void test_prepare_resultset()
|
|
{
|
|
MYSQL_STMT *stmt;
|
|
int rc,param_count;
|
|
char query[200];
|
|
MYSQL_RES *result;
|
|
|
|
myheader("test_prepare_resultset");
|
|
|
|
rc = mysql_autocommit(mysql, true);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_prepare_resultset");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"CREATE TABLE test_prepare_resultset(id int,\
|
|
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);
|
|
|
|
param_count = mysql_param_count(stmt);
|
|
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);
|
|
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);
|
|
}
|
|
|
|
/********************************************************
|
|
* to test field flags (verify .NET provider) *
|
|
*********************************************************/
|
|
|
|
void test_field_flags()
|
|
{
|
|
int rc;
|
|
MYSQL_RES *result;
|
|
MYSQL_FIELD *field;
|
|
unsigned int i;
|
|
|
|
|
|
myheader("test_field_flags");
|
|
|
|
rc = mysql_query(mysql,"DROP TABLE IF EXISTS test_field_flags");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
rc = mysql_query(mysql,"CREATE TABLE test_field_flags(id int NOT NULL AUTO_INCREMENT PRIMARY KEY,\
|
|
id1 int NOT NULL,\
|
|
id2 int UNIQUE,\
|
|
id3 int,\
|
|
id4 int NOT NULL,\
|
|
id5 int,\
|
|
KEY(id3,id4))");
|
|
myquery(rc);
|
|
|
|
rc = mysql_commit(mysql);
|
|
myquery(rc);
|
|
|
|
/* with table name included with true column name */
|
|
rc = mysql_query(mysql,"SELECT * FROM test_field_flags");
|
|
myquery(rc);
|
|
|
|
result = mysql_use_result(mysql);
|
|
mytest(result);
|
|
|
|
mysql_field_seek(result,0);
|
|
fputc('\n', stdout);
|
|
|
|
for(i=0; i< mysql_num_fields(result); i++)
|
|
{
|
|
field = mysql_fetch_field(result);
|
|
printf("\nfield:%d",i);
|
|
if(field->flags & NOT_NULL_FLAG)
|
|
printf("\n NOT_NULL_FLAG");
|
|
if(field->flags & PRI_KEY_FLAG)
|
|
printf("\n PRI_KEY_FLAG");
|
|
if(field->flags & UNIQUE_KEY_FLAG)
|
|
printf("\n UNIQUE_KEY_FLAG");
|
|
if(field->flags & MULTIPLE_KEY_FLAG)
|
|
printf("\n MULTIPLE_KEY_FLAG");
|
|
if(field->flags & AUTO_INCREMENT_FLAG)
|
|
printf("\n AUTO_INCREMENT_FLAG");
|
|
|
|
}
|
|
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,
|
|
0, 0, 0, 0, 0},
|
|
{"database", 'D', "Database to use", (gptr*) &opt_db, (gptr*) &opt_db,
|
|
0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
|
|
{"host", 'h', "Connect to host", (gptr*) &opt_host, (gptr*) &opt_host, 0, GET_STR_ALLOC,
|
|
REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
|
|
{"password", 'p',
|
|
"Password to use when connecting to server. If password is not given it's asked from the tty.",
|
|
0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
|
|
#ifndef DONT_ALLOW_USER_CHANGE
|
|
{"user", 'u', "User for login if not current user", (gptr*) &opt_user,
|
|
(gptr*) &opt_user, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
|
|
#endif
|
|
{"port", 'P', "Port number to use for connection", (gptr*) &opt_port,
|
|
(gptr*) &opt_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
|
|
{"socket", 'S', "Socket file to use for connection", (gptr*) &opt_unix_socket,
|
|
(gptr*) &opt_unix_socket, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
|
|
{ 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
|
|
};
|
|
|
|
static void usage(void)
|
|
{
|
|
/*
|
|
* show the usage string when the user asks for this
|
|
*/
|
|
puts("***********************************************************************\n");
|
|
puts(" Test for client-server protocol 4.1");
|
|
puts(" By Monty & Venu \n");
|
|
puts("This software comes with ABSOLUTELY NO WARRANTY. This is free software,");
|
|
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("\
|
|
-?, --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("\
|
|
-W, --pipe Use named pipes to connect to server.\n");
|
|
#endif
|
|
printf("\
|
|
-P, --port=... Port number to use for connection.\n\
|
|
-S, --socket=... Socket file to use for connection.\n");
|
|
#ifndef DONT_ALLOW_USER_CHANGE
|
|
printf("\
|
|
-u, --user=# User for login if not current user.\n");
|
|
#endif
|
|
printf("*********************************************************************\n");
|
|
}
|
|
|
|
static my_bool
|
|
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
|
|
char *argument)
|
|
{
|
|
switch (optid) {
|
|
case 'p':
|
|
if (argument)
|
|
{
|
|
char *start=argument;
|
|
my_free(opt_password, MYF(MY_ALLOW_ZERO_PTR));
|
|
opt_password= my_strdup(argument, MYF(MY_FAE));
|
|
while (*argument) *argument++= 'x'; /* Destroy argument */
|
|
if (*start)
|
|
start[1]=0;
|
|
}
|
|
else
|
|
tty_password= 1;
|
|
break;
|
|
case '?':
|
|
case 'I': /* Info */
|
|
usage();
|
|
exit(0);
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static const char *load_default_groups[]= { "client",0 };
|
|
|
|
static void get_options(int argc, char **argv)
|
|
{
|
|
int ho_error;
|
|
|
|
load_defaults("my",load_default_groups,&argc,&argv);
|
|
|
|
if ((ho_error=handle_options(&argc,&argv, myctest_long_options,
|
|
get_one_option)))
|
|
exit(ho_error);
|
|
|
|
/*free_defaults(argv);*/
|
|
if (tty_password)
|
|
opt_password=get_tty_password(NullS);
|
|
return;
|
|
}
|
|
|
|
/********************************************************
|
|
* main routine *
|
|
*********************************************************/
|
|
int main(int argc, char **argv)
|
|
{
|
|
MY_INIT(argv[0]);
|
|
get_options(argc,argv);
|
|
|
|
client_connect(); /* connect to server */
|
|
|
|
test_null(); /* test null data handling */
|
|
test_simple_update();
|
|
//test_select_simple();
|
|
//test_prepare_resultset();
|
|
//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_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_simple_delete(); /* prepare with delete */
|
|
test_field_names(); /* test for field names */
|
|
test_double_compare();/* float comparision */
|
|
client_query(); /* simple client query test */
|
|
client_store_result();/* usage of mysql_store_result() */
|
|
client_use_result(); /* usage of mysql_use_result() */
|
|
test_tran_bdb(); /* transaction test on BDB table type */
|
|
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_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_warnings(); /* show warnings test */
|
|
test_errors(); /* show errors test */
|
|
//test_select_simple(); /* simple select prepare */
|
|
//test_prepare_resultset();/* prepare meta info test */
|
|
|
|
client_disconnect(); /* disconnect from server */
|
|
|
|
fprintf(stdout,"\ndone !!!\n");
|
|
return(0);
|
|
}
|
|
|