int
main(int argc, char **argv)
{
CS_CONTEXT *ctx;
CS_CONNECTION *conn;
int ret = 1;
read_login_info();
if (cs_ctx_alloc(CS_VERSION_100, &ctx) != CS_SUCCEED) {
fprintf(stderr, "Context Alloc failed!\n");
return ret;
}
if (ct_init(ctx, CS_VERSION_100) != CS_SUCCEED) {
fprintf(stderr, "Library Init failed!\n");
return ret;
}
if (ct_con_alloc(ctx, &conn) != CS_SUCCEED) {
fprintf(stderr, "Connect Alloc failed!\n");
return ret;
}
if (ct_con_props(conn, CS_SET, CS_USERNAME, (CS_VOID*) "sa", CS_NULLTERM, NULL) != CS_SUCCEED) {
fprintf(stderr, "ct_con_props() SET USERNAME failed!\n");
return ret;
}
if (ct_con_props(conn, CS_SET, CS_PASSWORD, (CS_VOID*) "invalid", CS_NULLTERM, NULL) != CS_SUCCEED) {
fprintf(stderr, "ct_con_props() SET PASSWORD failed!\n");
return ret;
}
if (ct_connect(conn, SERVER, CS_NULLTERM) != CS_FAIL) {
fprintf(stderr, "Connection succeeded??\n");
return ret;
}
if (ct_cancel(conn, NULL, CS_CANCEL_ALL) != CS_SUCCEED) {
fprintf(stderr, "ct_cancel() failed!\n");
return ret;
}
if (ct_close(conn, CS_UNUSED) != CS_SUCCEED) {
fprintf(stderr, "ct_close() failed!\n");
return ret;
}
if (ct_con_drop(conn) != CS_SUCCEED) {
fprintf(stderr, "ct_con_drop() failed!\n");
return ret;
}
if (ct_exit(ctx, CS_UNUSED) != CS_SUCCEED) {
fprintf(stderr, "ct_exit() failed!\n");
return ret;
}
if (cs_ctx_drop(ctx) != CS_SUCCEED) {
fprintf(stderr, "cs_ctx_drop() failed!\n");
return ret;
}
fprintf(stdout, "Test succeeded\n");
return 0;
}
CAMLprim value mltds_ct_con_setstring(value conn, value field, value newval)
{
CAMLparam3(conn, field, newval);
retval_inspect( "ct_con_props",
ct_con_props(connection_ptr(conn),
CS_SET,
conprop_of_value(field),
String_val(newval),
string_length(newval),
NULL));
CAMLreturn(Val_unit);
}
/* Testing: Retrieve CS_TEXT_TYPE using ct_bind() */
int
main(int argc, char **argv)
{
CS_CONTEXT *ctx;
CS_COMMAND *cmd;
int i, verbose = 0;
CS_RETCODE ret;
CS_RETCODE ret2;
CS_RETCODE results_ret;
CS_INT result_type;
CS_INT num_cols;
CS_DATAFMT datafmt;
CS_INT datalength;
CS_SMALLINT ind;
CS_INT count, row_count = 0;
CS_INT id;
CS_CHAR name[600];
CS_CHAR *nameptr;
CS_INT getlen;
char large_sql[1024];
char len600[601];
char len800[801];
char temp[11];
char *textptr;
CS_IODESC iodesc;
int tds_version;
len600[0] = 0;
name[0] = 0;
for (i = 0; i < 60; i++) {
sprintf(temp, "_abcde_%03d", (i + 1) * 10);
strcat(len600, temp);
}
len600[600] = '\0';
len800[0] = 0;
for (i = 0; i < 80; i++) {
sprintf(temp, "_zzzzz_%03d", (i + 1) * 10);
strcat(len800, temp);
}
len800[800] = '\0';
fprintf(stdout, "%s: Retrieve CS_TEXT_TYPE using ct_bind()\n", __FILE__);
if (verbose) {
fprintf(stdout, "Trying login\n");
}
ret = try_ctlogin(&ctx, &conn, &cmd, verbose);
if (ret != CS_SUCCEED) {
fprintf(stderr, "Login failed\n");
return 1;
}
ret = ct_con_props(conn, CS_GET, CS_TDS_VERSION, &tds_version, CS_UNUSED, NULL);
if (ret == CS_SUCCEED) {
if (tds_version >= CS_TDS_72) {
printf("Protocol TDS7.2+ detected, test not supported\n");
try_ctlogout(ctx, conn, cmd, verbose);
return 0;
}
}
ret = run_command(cmd, "CREATE TABLE #test_table (id int, name text)");
if (ret != CS_SUCCEED)
return 1;
sprintf(large_sql, "INSERT #test_table (id, name) VALUES (2, '%s')", len600);
ret = run_command(cmd, large_sql);
if (ret != CS_SUCCEED)
return 1;
ret = ct_command(cmd, CS_LANG_CMD, "SELECT id, name FROM #test_table", CS_NULLTERM, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_command() failed\n");
return 1;
}
ret = ct_send(cmd);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_send() failed\n");
return 1;
}
while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
switch ((int) result_type) {
case CS_CMD_SUCCEED:
break;
case CS_CMD_DONE:
break;
case CS_CMD_FAIL:
fprintf(stderr, "ct_results() result_type CS_CMD_FAIL.\n");
return 1;
case CS_ROW_RESULT:
ret = ct_res_info(cmd, CS_NUMDATA, &num_cols, CS_UNUSED, NULL);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_res_info() failed");
return 1;
}
if (num_cols != 2) {
fprintf(stderr, "num_cols %d != 2", num_cols);
return 1;
}
ret = ct_describe(cmd, 1, &datafmt);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_describe() failed");
return 1;
}
datafmt.format = CS_FMT_UNUSED;
if (datafmt.maxlength > 1024) {
datafmt.maxlength = 1024;
}
ret = ct_bind(cmd, 1, &datafmt, &id, &datalength, &ind);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_bind() failed\n");
return 1;
}
while (((ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count)) == CS_SUCCEED)
|| (ret == CS_ROW_FAIL)) {
row_count += count;
if (ret == CS_ROW_FAIL) {
fprintf(stderr, "ct_fetch() CS_ROW_FAIL on row %d.\n", row_count);
return 1;
} else { /* ret == CS_SUCCEED */
if (verbose) {
fprintf(stdout, "id = '%d'\n", id);
}
nameptr = name;
while ((ret2 = ct_get_data(cmd, 2 , nameptr, 200, &getlen )) == CS_SUCCEED) {
nameptr += getlen;
}
if (ret2 != CS_END_DATA) {
fprintf(stderr, "ct_get_data() failed\n");
return 1;
}
if (memcmp(name, len600, 600)) {
fprintf(stderr, "Bad return data\n");
return 1;
}
fprintf(stdout, "%s: Trying ct_data_info on text column\n", __FILE__);
if (ct_data_info(cmd, CS_GET, 2, &iodesc) != CS_SUCCEED) {
fprintf(stderr, "ct_data_info() failed\n");
return 1;
} else {
fprintf(stdout, "datatype = %d\n", iodesc.datatype);
fprintf(stdout, "usertype = %d\n", iodesc.usertype);
fprintf(stdout, "text len = %d\n", iodesc.total_txtlen);
fprintf(stdout, "name = %*.*s\n", iodesc.namelen, iodesc.namelen, iodesc.name);
}
}
}
switch ((int) ret) {
case CS_END_DATA:
break;
case CS_FAIL:
fprintf(stderr, "ct_fetch() returned CS_FAIL.\n");
return 1;
default:
fprintf(stderr, "ct_fetch() unexpected return.\n");
return 1;
}
break;
case CS_COMPUTE_RESULT:
fprintf(stderr, "ct_results() unexpected CS_COMPUTE_RESULT.\n");
return 1;
default:
fprintf(stderr, "ct_results() unexpected result_type.\n");
return 1;
}
}
switch ((int) results_ret) {
case CS_END_RESULTS:
break;
case CS_FAIL:
fprintf(stderr, "ct_results() failed.\n");
return 1;
break;
default:
fprintf(stderr, "ct_results() unexpected return.\n");
return 1;
}
if ((ret = ct_command(cmd, CS_SEND_DATA_CMD, NULL, CS_UNUSED, CS_COLUMN_DATA)) != CS_SUCCEED) {
fprintf(stderr, "ct_command(CS_SEND_DATA_CMD) failed.\n");
return 1;
}
iodesc.total_txtlen = 800;
iodesc.log_on_update = CS_TRUE;
if (ct_data_info(cmd, CS_SET, CS_UNUSED, &iodesc) != CS_SUCCEED) {
fprintf(stderr, "ct_data_info() failed\n");
return 1;
}
for ( i = 0 ; i < 800 ; i += 200 ) {
textptr = &len800[i];
ret = ct_send_data(cmd, textptr, (CS_INT) 200);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_send_data failed\n");
return 1;
}
}
ret = ct_send(cmd);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_send failed\n");
return 1;
}
while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
switch ((int) result_type) {
case CS_CMD_SUCCEED:
break;
case CS_CMD_DONE:
break;
case CS_CMD_FAIL:
fprintf(stderr, "ct_results() result_type CS_CMD_FAIL.\n");
return 1;
case CS_ROW_RESULT:
break;
case CS_PARAM_RESULT:
break;
case CS_COMPUTE_RESULT:
fprintf(stderr, "ct_results() unexpected CS_COMPUTE_RESULT.\n");
return 1;
default:
fprintf(stderr, "ct_results() unexpected result_type.\n");
return 1;
}
}
switch ((int) results_ret) {
case CS_END_RESULTS:
break;
case CS_FAIL:
fprintf(stderr, "ct_results() failed.\n");
return 1;
break;
default:
fprintf(stderr, "ct_results() unexpected return.\n");
return 1;
}
if (verbose) {
fprintf(stdout, "Trying logout\n");
}
ret = try_ctlogout(ctx, conn, cmd, verbose);
if (ret != CS_SUCCEED) {
fprintf(stderr, "Logout failed\n");
return 1;
}
return 0;
}
static VALUE connection_Initialize(VALUE self, VALUE connection_hash) {
TDS_Connection* conn;
char *servername = NULL;
char *username = NULL;
char *password = NULL;
char *confile = NULL;
char *charset = NULL;
VALUE temp;
VALUE errors;
CS_RETCODE ret;
Data_Get_Struct(self, TDS_Connection, conn);
cs_ctx_alloc(CS_VERSION_100, &conn->context);
ct_init(conn->context, CS_VERSION_100);
ct_con_alloc(conn->context, &conn->connection);
// conn->context->msg_handler = connection_handle_message;
// conn->context->err_handler = connection_handle_message;
/* now let's get the connection parameters */
temp = rb_hash_aref(connection_hash, ID2SYM(rb_intern("username")));
username = value_to_cstr(temp);
temp = rb_hash_aref(connection_hash, ID2SYM(rb_intern("password")));
password = value_to_cstr(temp);
temp = rb_hash_aref(connection_hash, ID2SYM(rb_intern("servername")));
servername = value_to_cstr(temp);
temp = rb_hash_aref(connection_hash, ID2SYM(rb_intern("charset")));
charset = value_to_cstr(temp);
if(charset==NULL) {
charset = strdup("ISO-8859-1");
}
/* validate parameters */
if (!servername) {
rb_raise(rb_eArgError, "You must specify a servername");
return Qnil;
}
if (!username) {
rb_raise(rb_eArgError, "No username specified");
return Qnil;
}
if (!password) {
password = strdup("");
}
// printf("*** servername='%s', username='******' password='******'\n", servername, username, password);
ct_con_props(conn->connection, CS_SET, CS_USERNAME, username, CS_NULLTERM, NULL);
ct_con_props(conn->connection, CS_SET, CS_PASSWORD, password, CS_NULLTERM, NULL);
/* Try to open a connection */
ret = ct_connect(conn->connection, servername, CS_NULLTERM);
/* free up all the memory */
if (username) {
free(username);
username = NULL;
}
if (password) {
free(password);
password = NULL;
}
if (servername) {
free(servername);
}
if(ret!=CS_SUCCEED) {
rb_raise(rb_eIOError, "Connection failed");
return Qnil;
}
rb_iv_set(self, "@messages", rb_ary_new());
errors = rb_ary_new();
rb_iv_set(self, "@errors", errors);
return Qnil;
}
CS_RETCODE
try_ctlogin(CS_CONTEXT ** ctx, CS_CONNECTION ** conn, CS_COMMAND ** cmd, int verbose)
{
CS_RETCODE ret;
char query[30];
TDSCONTEXT *tds_ctx;
/* read login information from PWD file */
ret = read_login_info();
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "read_login_info() failed!\n");
}
return ret;
}
ret = cs_ctx_alloc(CS_VERSION_100, ctx);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Context Alloc failed!\n");
}
return ret;
}
/* Force default date format, some tests rely on it */
tds_ctx = (TDSCONTEXT *) (*ctx)->tds_ctx;
if (tds_ctx && tds_ctx->locale && tds_ctx->locale->date_fmt) {
free(tds_ctx->locale->date_fmt);
tds_ctx->locale->date_fmt = tds_strdup("%b %d %Y %I:%M%p");
}
ret = ct_init(*ctx, CS_VERSION_100);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Library Init failed!\n");
}
return ret;
}
ret = ct_con_alloc(*ctx, conn);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Connect Alloc failed!\n");
}
return ret;
}
ret = ct_con_props(*conn, CS_SET, CS_USERNAME, USER, CS_NULLTERM, NULL);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "ct_con_props() SET USERNAME failed!\n");
}
return ret;
}
ret = ct_con_props(*conn, CS_SET, CS_PASSWORD, PASSWORD, CS_NULLTERM, NULL);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "ct_con_props() SET PASSWORD failed!\n");
}
return ret;
}
ret = ct_connect(*conn, SERVER, CS_NULLTERM);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Connection failed!\n");
}
return ret;
}
ret = ct_cmd_alloc(*conn, cmd);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Command Alloc failed!\n");
}
return ret;
}
strcpy(query, "use ");
strncat(query, DATABASE, 20);
ret = run_command(*cmd, query);
if (ret != CS_SUCCEED)
return ret;
return CS_SUCCEED;
}
CS_RETCODE
continue_logging_in(CS_CONTEXT ** ctx, CS_CONNECTION ** conn, CS_COMMAND ** cmd, int verbose)
{
CS_RETCODE ret;
char query[30];
#ifdef TDS_STATIC_CAST
TDSCONTEXT *tds_ctx;
#endif
ret = cs_ctx_alloc(CS_VERSION_100, ctx);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Context Alloc failed!\n");
}
return ret;
}
#ifdef TDS_STATIC_CAST
/* Force default date format, some tests rely on it */
tds_ctx = (TDSCONTEXT *) (*ctx)->tds_ctx;
if (tds_ctx && tds_ctx->locale && tds_ctx->locale->date_fmt) {
free(tds_ctx->locale->date_fmt);
tds_ctx->locale->date_fmt = strdup("%b %d %Y %I:%M%p");
}
#endif
ret = ct_init(*ctx, CS_VERSION_100);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Library Init failed!\n");
}
return ret;
}
if ((ret = ct_callback(*ctx, NULL, CS_SET, CS_CLIENTMSG_CB,
(CS_VOID*) clientmsg_cb)) != CS_SUCCEED) {
fprintf(stderr, "ct_callback() failed\n");
return ret;
}
if ((ret = ct_callback(*ctx, NULL, CS_SET, CS_SERVERMSG_CB, servermsg_cb)) != CS_SUCCEED) {
fprintf(stderr, "ct_callback() failed\n");
return ret;
}
ret = ct_con_alloc(*ctx, conn);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Connect Alloc failed!\n");
}
return ret;
}
ret = ct_con_props(*conn, CS_SET, CS_USERNAME, USER, CS_NULLTERM, NULL);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "ct_con_props() SET USERNAME failed!\n");
}
return ret;
}
ret = ct_con_props(*conn, CS_SET, CS_PASSWORD, PASSWORD, CS_NULLTERM, NULL);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "ct_con_props() SET PASSWORD failed!\n");
}
return ret;
}
printf("connecting as %s to %s.%s\n", USER, SERVER, DATABASE);
ret = ct_connect(*conn, SERVER, CS_NULLTERM);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Connection failed!\n");
}
return ret;
}
ret = ct_cmd_alloc(*conn, cmd);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Command Alloc failed!\n");
}
return ret;
}
strcpy(query, "use ");
strncat(query, DATABASE, 20);
ret = run_command(*cmd, query);
if (ret != CS_SUCCEED)
return ret;
return CS_SUCCEED;
}
CS_RETCODE SybConnection::connect_(const char *app, const char *addr,
const char *user, const char *pwd, const char *db)
{
CS_RETCODE retcode;
CS_BOOL hafailover = CS_TRUE;
// Allocate a connection structure.
retcode = ct_con_alloc(sContext_, &conn_);
if (retcode != CS_SUCCEED) {
SysLogger::error("connect_: ct_con_alloc() failed");
return retcode;
}
// If a appname is defined, set the CS_APPNAME property.
if (app != NULL) {
retcode = ct_con_props(conn_, CS_SET, CS_APPNAME,
(CS_VOID*)app, CS_NULLTERM, NULL);
if (retcode != CS_SUCCEED) {
SysLogger::error("connect_: ct_con_props(CS_APPNAME) failed");
ct_con_drop(conn_);
conn_ = NULL;
return retcode;
}
}
// If a servername is defined, set the CS_SERVERNAME property.
if (addr != NULL) {
retcode = ct_con_props(conn_, CS_SET, CS_SERVERADDR,
(CS_VOID*)addr, CS_NULLTERM, NULL);
if (retcode != CS_SUCCEED) {
SysLogger::error("connect_: ct_con_props(CS_SERVERADDR) failed");
ct_con_drop(conn_);
conn_ = NULL;
return retcode;
}
}
// If a username is defined, set the CS_USERNAME property.
if (user != NULL) {
retcode = ct_con_props(conn_, CS_SET, CS_USERNAME,
(CS_VOID*)user, CS_NULLTERM, NULL);
if (retcode != CS_SUCCEED) {
SysLogger::error("connect_: ct_con_props(CS_USERNAME) failed");
ct_con_drop(conn_);
conn_ = NULL;
return retcode;
}
}
// If a password is defined, set the CS_PASSWORD property.
if (pwd != NULL) {
retcode = ct_con_props(conn_, CS_SET, CS_PASSWORD,
(CS_VOID*)pwd, CS_NULLTERM, NULL);
if (retcode != CS_SUCCEED) {
SysLogger::error("connect_: ct_con_props(CS_PASSWORD) failed");
ct_con_drop(conn_);
conn_ = NULL;
return retcode;
}
}
// Set the CS_HAFAILOVER property.
retcode = ct_con_props(conn_, CS_SET, CS_HAFAILOVER,
&hafailover, CS_UNUSED, NULL);
if (retcode != CS_SUCCEED) {
SysLogger::error("connect_: ct_con_props(CS_HAFAILOVER) failed");
ct_con_drop(conn_);
conn_ = NULL;
return retcode;
}
// Connect to the server.
retcode = ct_connect(conn_, NULL, CS_UNUSED);
if (retcode != CS_SUCCEED) {
SysLogger::error("connect_: ct_connect() failed");
ct_con_drop(conn_);
conn_ = NULL;
return retcode;
}
return CS_SUCCEED;
}
static int
insert_test(CS_CONNECTION *conn, CS_COMMAND *cmd, int useNames)
{
CS_CONTEXT *ctx;
CS_RETCODE ret;
CS_INT res_type;
CS_DATAFMT datafmt;
CS_DATAFMT srcfmt;
CS_DATAFMT destfmt;
CS_INT intvar;
CS_FLOAT floatvar;
CS_MONEY moneyvar;
CS_DATEREC datevar;
char moneystring[10];
char dummy_name[30];
char dummy_name2[20];
CS_INT destlen;
/* clear table */
run_command(cmd, "delete #ctparam_lang");
/*
* Assign values to the variables used for parameter passing.
*/
intvar = 2;
floatvar = 0.12;
strcpy(dummy_name, "joe blow");
strcpy(dummy_name2, "");
strcpy(moneystring, "300.90");
/*
* Clear and setup the CS_DATAFMT structures used to convert datatypes.
*/
memset(&srcfmt, 0, sizeof(CS_DATAFMT));
srcfmt.datatype = CS_CHAR_TYPE;
srcfmt.maxlength = (CS_INT)strlen(moneystring);
srcfmt.precision = 5;
srcfmt.scale = 2;
srcfmt.locale = NULL;
memset(&destfmt, 0, sizeof(CS_DATAFMT));
destfmt.datatype = CS_MONEY_TYPE;
destfmt.maxlength = sizeof(CS_MONEY);
destfmt.precision = 5;
destfmt.scale = 2;
destfmt.locale = NULL;
/*
* Convert the string representing the money value
* to a CS_MONEY variable. Since this routine does not have the
* context handle, we use the property functions to get it.
*/
if ((ret = ct_cmd_props(cmd, CS_GET, CS_PARENT_HANDLE, &conn, CS_UNUSED, NULL)) != CS_SUCCEED) {
fprintf(stderr, "ct_cmd_props() failed\n");
return 1;
}
if ((ret = ct_con_props(conn, CS_GET, CS_PARENT_HANDLE, &ctx, CS_UNUSED, NULL)) != CS_SUCCEED) {
fprintf(stderr, "ct_con_props() failed\n");
return 1;
}
ret = cs_convert(ctx, &srcfmt, (CS_VOID *) moneystring, &destfmt, &moneyvar, &destlen);
if (ret != CS_SUCCEED) {
fprintf(stderr, "cs_convert() failed\n");
return 1;
}
/*
* create the command
*/
if ((ret = ct_command(cmd, CS_LANG_CMD, query, (CS_INT)strlen(query),
CS_UNUSED)) != CS_SUCCEED)
{
fprintf(stderr, "ct_command(CS_LANG_CMD) failed\n");
return 1;
}
/*
* Clear and setup the CS_DATAFMT structure, then pass
* each of the parameters for the query.
*/
memset(&datafmt, 0, sizeof(datafmt));
if (useNames)
strcpy(datafmt.name, "@in1");
else
datafmt.name[0] = 0;
datafmt.maxlength = 255;
datafmt.namelen = CS_NULLTERM;
datafmt.datatype = CS_CHAR_TYPE;
datafmt.status = CS_INPUTVALUE;
/*
* The character string variable is filled in by the RPC so pass NULL
* for the data 0 for data length, and -1 for the indicator arguments.
*/
ret = ct_param(cmd, &datafmt, dummy_name, (CS_INT)strlen(dummy_name), 0);
if (CS_SUCCEED != ret) {
fprintf(stderr, "ct_param(char) failed\n");
return 1;
}
if (useNames)
strcpy(datafmt.name, "@in2");
else
datafmt.name[0] = 0;
datafmt.maxlength = 255;
datafmt.namelen = CS_NULLTERM;
datafmt.datatype = CS_CHAR_TYPE;
datafmt.status = CS_INPUTVALUE;
ret = ct_param(cmd, &datafmt, dummy_name2, (CS_INT)strlen(dummy_name2), 0);
if (CS_SUCCEED != ret) {
fprintf(stderr, "ct_param(char) failed\n");
return 1;
}
if (useNames)
strcpy(datafmt.name, "@in3");
else
datafmt.name[0] = 0;
datafmt.namelen = CS_NULLTERM;
datafmt.datatype = CS_INT_TYPE;
datafmt.status = CS_INPUTVALUE;
ret = ct_param(cmd, &datafmt, (CS_VOID *) & intvar, CS_SIZEOF(CS_INT), 0);
if (CS_SUCCEED != ret) {
fprintf(stderr, "ct_param(int) failed\n");
return 1;
}
if (useNames)
strcpy(datafmt.name, "@moneyval");
else
datafmt.name[0] = 0;
datafmt.namelen = CS_NULLTERM;
datafmt.datatype = CS_MONEY_TYPE;
datafmt.status = CS_INPUTVALUE;
ret = ct_param(cmd, &datafmt, (CS_VOID *) & moneyvar, CS_SIZEOF(CS_MONEY), 0);
if (CS_SUCCEED != ret) {
fprintf(stderr, "ct_param(money) failed\n");
return 1;
}
if (useNames)
strcpy(datafmt.name, "@dateval");
else
datafmt.name[0] = 0;
datafmt.namelen = CS_NULLTERM;
datafmt.datatype = CS_DATETIME_TYPE;
datafmt.status = CS_INPUTVALUE;
memset(&datevar, 0, sizeof(CS_DATEREC));
datevar.dateyear = 2003;
datevar.datemonth = 2;
datevar.datedmonth = 1;
ret = ct_param(cmd, &datafmt, &datevar, 0, 0);
if (CS_SUCCEED != ret) {
fprintf(stderr, "ct_param(datetime) failed");
return 1;
}
if (useNames)
strcpy(datafmt.name, "@floatval");
else
datafmt.name[0] = 0;
datafmt.namelen = CS_NULLTERM;
datafmt.datatype = CS_FLOAT_TYPE;
datafmt.status = CS_INPUTVALUE;
ret = ct_param(cmd, &datafmt, &floatvar, 0, 0);
if (CS_SUCCEED != ret) {
fprintf(stderr, "ct_param(float) failed");
return 1;
}
/*
* Send the command to the server
*/
if (ct_send(cmd) != CS_SUCCEED) {
fprintf(stderr, "ct_send(CS_LANG_CMD) failed\n");
return 1;
}
/*
* Process the results.
*/
while ((ret = ct_results(cmd, &res_type)) == CS_SUCCEED) {
switch ((int) res_type) {
case CS_CMD_SUCCEED:
case CS_CMD_DONE:
{
CS_INT rowsAffected=0;
ct_res_info(cmd, CS_ROW_COUNT, &rowsAffected, CS_UNUSED, NULL);
if (1 != rowsAffected)
fprintf(stderr, "insert touched %d rows instead of 1\n", rowsAffected);
}
break;
case CS_CMD_FAIL:
/*
* The server encountered an error while
* processing our command.
*/
fprintf(stderr, "ct_results returned CS_CMD_FAIL.\n");
break;
case CS_STATUS_RESULT:
/*
* The server encountered an error while
* processing our command.
*/
fprintf(stderr, "ct_results returned CS_STATUS_RESULT.\n");
break;
default:
/*
* We got something unexpected.
*/
fprintf(stderr, "ct_results returned unexpected result type %d\n", res_type);
return 1;
}
}
if (ret != CS_END_RESULTS)
fprintf(stderr, "ct_results returned unexpected result %d.\n", (int) ret);
/* test row inserted */
ret = run_command(cmd, "if not exists(select * from #ctparam_lang where name = 'joe blow' and name2 is not null and age = 2) select 1");
if (ret != CS_SUCCEED) {
fprintf(stderr, "check row inserted failed\n");
exit(1);
}
return 0;
}
