int
main(int argc, char **argv)
{
CS_CONTEXT *ctx;
CS_CONNECTION *conn;
CS_COMMAND *cmd;
CS_COMMAND *cmd2;
CS_RETCODE ret;
CS_RETCODE results_ret;
CS_INT result_type;
CS_INT count, row_count = 0;
CS_DATAFMT datafmt;
CS_SMALLINT ind;
int verbose = 1;
CS_CHAR name[3];
CS_CHAR col1[6];
CS_INT datalength;
CS_CHAR text[128];
CS_INT num_cols, i, j;
int is_return_status = 0;
CS_INT props_value;
fprintf(stdout, "%s: Testing ct_cursor()\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_cmd_alloc(conn, &cmd2);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Command Alloc failed!\n");
}
return ret;
}
ret = run_command(cmd, "CREATE TABLE #test_table (col1 char(4))");
if (ret != CS_SUCCEED)
return 1;
ret = run_command(cmd, "INSERT #test_table (col1) VALUES ('AAA')");
if (ret != CS_SUCCEED)
return 1;
ret = run_command(cmd, "INSERT #test_table (col1) VALUES ('BBB')");
if (ret != CS_SUCCEED)
return 1;
ret = run_command(cmd, "INSERT #test_table (col1) VALUES ('CCC')");
if (ret != CS_SUCCEED)
return 1;
ret = run_command(cmd2, "CREATE TABLE #test_table2 (col1 char(4))");
if (ret != CS_SUCCEED)
return 1;
ret = run_command(cmd2, "INSERT #test_table2 (col1) VALUES ('---')");
if (ret != CS_SUCCEED)
return 1;
if (verbose) {
fprintf(stdout, "Trying declare, rows , open in one SEND\n");
}
strcpy(text, "select col1 from #test_table where 1 = 1");
strcpy(name, "c1");
ret = ct_cursor(cmd, CS_CURSOR_DECLARE, name, CS_NULLTERM, text, CS_NULLTERM, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor declare failed\n");
return 1;
}
ret = ct_cursor(cmd, CS_CURSOR_ROWS, name, CS_NULLTERM, NULL, CS_UNUSED, (CS_INT) 1);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor set cursor rows failed");
return 1;
}
ret = ct_cursor(cmd, CS_CURSOR_OPEN, name, CS_NULLTERM, text, CS_NULLTERM, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor open failed\n");
return 1;
}
ret = ct_send(cmd);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_send failed\n");
}
while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
switch ((int) result_type) {
case CS_CMD_SUCCEED:
case CS_CMD_DONE:
case CS_CMD_FAIL:
case CS_STATUS_RESULT:
break;
case CS_CURSOR_RESULT:
ret = ct_cmd_props(cmd, CS_GET, CS_CUR_STATUS, &props_value, sizeof(CS_INT), NULL);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cmd_props() failed\n");
return 1;
}
if (props_value & CS_CURSTAT_DECLARED) {
fprintf(stderr, "ct_cmd_props claims cursor is in DECLARED state when it should be OPEN\n");
return 1;
}
if (!(props_value & CS_CURSTAT_OPEN)) {
fprintf(stderr, "ct_cmd_props claims cursor is not in OPEN state when it should be \n");
return 1;
}
if (props_value & CS_CURSTAT_CLOSED) {
fprintf(stderr, "ct_cmd_props claims cursor is in CLOSED state when it should be OPEN\n");
return 1;
}
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 != 1) {
fprintf(stderr, "unexpected num of columns = %d \n", num_cols);
return 1;
}
for (i = 0; i < num_cols; i++) {
/* here we can finally test for the return status column */
ret = ct_describe(cmd, i + 1, &datafmt);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_describe() failed for column %d\n", i);
return 1;
}
if (datafmt.status & CS_RETURN) {
fprintf(stdout, "ct_describe() column %d \n", i);
is_return_status = i + 1;
}
datafmt.datatype = CS_CHAR_TYPE;
datafmt.format = CS_FMT_NULLTERM;
datafmt.maxlength = 6;
datafmt.count = 1;
datafmt.locale = NULL;
ret = ct_bind(cmd, 1, &datafmt, col1, &datalength, &ind);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_bind() failed\n");
return 1;
}
}
row_count = 0;
while (((ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count)) == CS_SUCCEED)
|| (ret == CS_ROW_FAIL)) {
if (row_count == 0) {
for (j = 0; j < num_cols; j++) {
fprintf(stdout, "\n%s\n", datafmt.name);
}
fprintf(stdout, "------\n\n");
}
for (j = 0; j < num_cols; j++) {
fprintf(stdout, "%s\n\n", col1);
row_count++;
}
ret = update_second_table(cmd2, col1);
if (ret)
return ret;
}
switch ((int) ret) {
case CS_END_DATA:
break;
case CS_ROW_FAIL:
fprintf(stderr, "ct_fetch() CS_ROW_FAIL on row %d.\n", row_count);
return 1;
case CS_FAIL:
fprintf(stderr, "ct_fetch() returned CS_FAIL.\n");
return 1;
default:
fprintf(stderr, "ct_fetch() unexpected return. %d\n", ret);
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;
}
}
ret = ct_cursor(cmd, CS_CURSOR_CLOSE, name, CS_NULLTERM, NULL, CS_UNUSED, CS_DEALLOC);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor(close) failed\n");
return ret;
}
if ((ret = ct_send(cmd)) != CS_SUCCEED) {
fprintf(stderr, "BILL ct_send() failed\n");
return ret;
}
while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
if (result_type == CS_CMD_FAIL) {
fprintf(stderr, "ct_results(2) result_type CS_CMD_FAIL.\n");
return 1;
}
}
if (results_ret != CS_END_RESULTS) {
fprintf(stderr, "ct_results() returned BAD.\n");
return 1;
}
ret = ct_cmd_props(cmd, CS_GET, CS_CUR_STATUS, &props_value, sizeof(CS_INT), NULL);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cmd_props() failed");
return 1;
}
if (props_value != CS_CURSTAT_NONE) {
fprintf(stderr, "ct_cmd_props() CS_CUR_STATUS != CS_CURSTAT_NONE \n");
return 1;
}
if (verbose) {
fprintf(stdout, "Trying declare, rows, open one at a time \n");
}
strcpy(text, "select col1 from #test_table where 2 = 2");
ret = ct_cursor(cmd, CS_CURSOR_DECLARE, name, 3, text, CS_NULLTERM, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor declare failed\n");
return 1;
}
ret = ct_send(cmd);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_send failed\n");
}
while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
if (result_type == CS_CMD_FAIL) {
fprintf(stderr, "ct_results(4) result_type CS_CMD_FAIL.\n");
return 1;
}
}
if (results_ret != CS_END_RESULTS) {
fprintf(stderr, "ct_results() returned BAD.\n");
return 1;
}
ret = ct_cursor(cmd, CS_CURSOR_ROWS, name, 3, NULL, CS_UNUSED, (CS_INT) 1);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor set cursor rows failed");
return 1;
}
ret = ct_send(cmd);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_send failed\n");
}
while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
if (result_type == CS_CMD_FAIL) {
fprintf(stderr, "ct_results(5) result_type CS_CMD_FAIL.\n");
return 1;
}
}
if (results_ret != CS_END_RESULTS) {
fprintf(stderr, "ct_results() returned BAD.\n");
return 1;
}
ret = ct_cursor(cmd, CS_CURSOR_OPEN, name, 3, text, 26, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor open failed\n");
return 1;
}
ret = ct_send(cmd);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_send failed\n");
}
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(6) result_type CS_CMD_FAIL.\n");
break;
case CS_STATUS_RESULT:
fprintf(stdout, "ct_results: CS_STATUS_RESULT detected for sp_who\n");
case CS_CURSOR_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 != 1) {
fprintf(stderr, "unexpected num of columns = %d \n", num_cols);
return 1;
}
for (i = 0; i < num_cols; i++) {
/* here we can finally test for the return status column */
ret = ct_describe(cmd, i + 1, &datafmt);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_describe() failed for column %d\n", i);
return 1;
}
if (datafmt.status & CS_RETURN) {
fprintf(stdout, "ct_describe() column %d \n", i);
is_return_status = i + 1;
}
datafmt.datatype = CS_CHAR_TYPE;
datafmt.format = CS_FMT_NULLTERM;
datafmt.maxlength = 6;
datafmt.count = 1;
datafmt.locale = NULL;
ret = ct_bind(cmd, 1, &datafmt, col1, &datalength, &ind);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_bind() failed\n");
return 1;
}
}
row_count = 0;
while (((ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count)) == CS_SUCCEED)
|| (ret == CS_ROW_FAIL)) {
if (row_count == 0) {
for (j = 0; j < num_cols; j++) {
fprintf(stdout, "\n%s\n", datafmt.name);
}
fprintf(stdout, "------\n\n");
}
for (j = 0; j < num_cols; j++) {
fprintf(stdout, "%s\n\n", col1);
row_count++;
}
}
switch ((int) ret) {
case CS_END_DATA:
break;
case CS_ROW_FAIL:
fprintf(stderr, "ct_fetch() CS_ROW_FAIL on row %d.\n", row_count);
return 1;
case CS_FAIL:
fprintf(stderr, "ct_fetch() returned CS_FAIL.\n");
return 1;
default:
fprintf(stderr, "ct_fetch() unexpected return. %d\n", ret);
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;
}
}
ret = ct_cursor(cmd, CS_CURSOR_CLOSE, name, 3, NULL, CS_UNUSED, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor(close) failed\n");
return ret;
}
if ((ret = ct_send(cmd)) != CS_SUCCEED) {
fprintf(stderr, "ct_send() failed\n");
return ret;
}
while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
if (result_type == CS_CMD_FAIL) {
fprintf(stderr, "ct_results(7) result_type CS_CMD_FAIL.\n");
return 1;
}
}
if (results_ret != CS_END_RESULTS) {
fprintf(stderr, "ct_results() returned BAD.\n");
return 1;
}
ret = ct_cursor(cmd, CS_CURSOR_DEALLOC, name, 3, NULL, CS_UNUSED, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor(dealloc) failed\n");
return ret;
}
if ((ret = ct_send(cmd)) != CS_SUCCEED) {
fprintf(stderr, "ct_send() failed\n");
return ret;
}
while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
if (result_type == CS_CMD_FAIL) {
fprintf(stderr, "ct_results(8) result_type CS_CMD_FAIL.\n");
return 1;
}
}
if (results_ret != CS_END_RESULTS) {
fprintf(stderr, "ct_results() returned BAD.\n");
return 1;
}
if (verbose) {
fprintf(stdout, "Running normal select command after cursor operations\n");
}
ret = ct_command(cmd, CS_LANG_CMD, "select col1 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:
datafmt.datatype = CS_CHAR_TYPE;
datafmt.format = CS_FMT_NULLTERM;
datafmt.maxlength = 6;
datafmt.count = 1;
datafmt.locale = NULL;
ret = ct_bind(cmd, 1, &datafmt, col1, &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 if (ret == CS_SUCCEED) {
;
} else {
break;
}
}
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.%d\n", ret);
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. %d\n", result_type);
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");
}
ct_cmd_drop(cmd2);
ret = try_ctlogout(ctx, conn, cmd, verbose);
if (ret != CS_SUCCEED) {
fprintf(stderr, "Logout failed\n");
return 2;
}
if (verbose) {
fprintf(stdout, "Test suceeded\n");
}
return 0;
}
/* Testing: Test order of ct_results() */
int
main(int argc, char **argv)
{
CS_CONTEXT *ctx;
CS_CONNECTION *conn;
CS_COMMAND *cmd;
int i, verbose = 0;
CS_RETCODE ret;
CS_RETCODE results_ret;
char query[1024];
CS_INT insert_results[] = { CS_CMD_SUCCEED, CS_CMD_DONE };
CS_INT update_results[] = { CS_CMD_SUCCEED, CS_CMD_DONE };
CS_INT select_results[] = { CS_ROW_RESULT, CS_CMD_DONE };
fprintf(stdout, "%s: Check ordering of returns from cs_results()\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 = run_command(cmd, "CREATE TABLE #t0004 (id int)");
if (ret != CS_SUCCEED)
return 1;
for (i = 0; i < NUMROWS; i++) {
sprintf(query, "INSERT #t0004 (id) VALUES (%d)", i);
ret = ct_command(cmd, CS_LANG_CMD, query, 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;
}
results_ret = do_results(cmd, insert_results);
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;
}
}
ret = ct_command(cmd, CS_LANG_CMD, "UPDATE #t0004 SET id = id + 1", 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;
}
results_ret = do_results(cmd, update_results);
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;
}
/* single row select */
ret = ct_command(cmd, CS_LANG_CMD, "SELECT * FROM #t0004 WHERE id = 1", 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;
}
results_ret = do_results(cmd, select_results);
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;
}
/* Testing: Retrieve CS_TEXT_TYPE using ct_bind() */
int
main(int argc, char **argv)
{
CS_CONTEXT *ctx;
CS_CONNECTION *conn;
CS_COMMAND *cmd;
int i, verbose = 0;
CS_RETCODE ret;
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_CHAR name[1024];
char large_sql[1024];
char len600[601];
char temp[11];
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';
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 = run_command(cmd, "CREATE TABLE #test_table (id int, name text)");
if (ret != CS_SUCCEED)
return 1;
/*
ret = run_command(cmd, "INSERT #test_table (id, name) VALUES (1, 'name1')");
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 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 != 1) {
fprintf(stderr, "num_cols %d != 1", 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_NULLTERM;
if (datafmt.maxlength > 1024) {
datafmt.maxlength = 1024;
}
ret = ct_bind(cmd, 1, &datafmt, name, &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, "name = '%s'\n", name);
}
if (strcmp(name, len600)) {
fprintf(stderr, "Bad return:\n'%s'\n! =\n'%s'\n", name, len600);
return 1;
}
if (datalength != strlen(name) + 1) {
fprintf(stderr, "Bad count:\n'%ld'\n! =\n'%d'\n", (long) strlen(name) + 1, count);
return 1;
}
}
}
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 (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 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;
}
CAMLprim value mltds_ct_send(value cmd)
{
CAMLparam1(cmd);
retval_inspect( "ct_send", ct_send(command_ptr(cmd)));
CAMLreturn( Val_unit );
}
